Meydan okuma

Gibi bir dize Verilen Hello World!onun karakter değerlerine içine yıkmak,: 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33.

Sonra karakterlerin her ardışık çifti arasındaki farkı hesaplamak: 29, 7, 0, 3, -79, 55, 24, 3, -6, -8, -67.

Son olarak, bunları topladığınızda ve nihai sonucu yazdırmak: -39.

kurallar

• Standart boşluklar geçerlidir
• Bu görevi yerine getiren önceden yapılmış işlevleri kullanmamak
• Yaratıcı çözümler teşvik edildi
• İyi eğlenceler
• Bu kod golf olarak işaretlenir , bayt cinsinden en kısa cevap kazanır, ancak seçilmez.

Python, 29 bayt

lambda s:ord(s[-1])-ord(s[0])

Farklılıkların toplamı teleskopik bir seri oluşturur, bu nedenle çoğu summand iptal edilir ve
(s ₁ - s ₀ ) + (s ₂ - s ₁ ) +… + (s _n-1 - s _n-2 ) + (s _n - s _n-1 ) = s _n - s ₀ .

Girdi olarak bir bayt dizesi alınırsa

lambda s:s[-1]-s[0]

19 bayt için de çalışır .

İkisini de Ideone'da test edin .

MATL , 2 bayt

ds

Çevrimiçi deneyin!

Açıklama:

dart arda gelen karakterler arasındaki farkı alır ve selde edilen diziyi toplar. Ardından, yığının üstündeki değer örtülü olarak yazdırılır. Bununla ilgili söylenecek başka bir şey yok.

İlginçtir, Dennis harika bir kısayol keşfetmiş olsa da, bunu MATL'de kullanmak daha uzun olacaktır.

Jöle , 3 bayt

OIS

Çevrimiçi deneyin!

Al Ogirdi dize ait karakterlerin rdinals sonra Io zaman, bu listenin ncrements Sum arasında olduğu listede.

MATLAB, 16 bayt

@(x)sum(diff(x))

Bu adında bir anonim işlevi oluşturur ansgibi çağrılabilir: ans('Hello world!').

İşte Octave'de , elemanlar arası farkı hesaplamadan önce giriş dizesini sayısal bir diziye açıkça dönüştürmek için ek bir bayt gerektiren çevrimiçi bir demo+

Python, 63 bayt

x=map(ord,input())
print sum(map(lambda(a,b):b-a,zip(x,x[1:])))

Boşver!

Cubix , 13 bayt

Cubix, bir küpün etrafına sarılmış 2 boyutlu bir dildir.

i?u//O-t#;/.@

Çevrimiçi test edin! Bu, aşağıdaki küp ağıyla eşleşir:

    i ?
    u /
/ O - t # ; / .
@ . . . . . . .
    . .
    . .

IP'nin (talimat işaretçisi) en soldaki yüzün sol üst köşesinde başladığı yer.

Nasıl çalışır

İlk olarak IP , üst yüze /yönlendiren aynaya çarpar i. Üst yüz, EOF'a ulaşılana kadar sürekli olarak kodları giren bir döngüdür. Giriş boş olduğunda, sonucu i-1 olur; IP en sağdaki yüze ?vurarak /ve aşağıdaki komutlardan geçerek sola döner :

• ; - Üst öğeyi (-1) açın.
• # - Yığının uzunluğunu itin.
• t- En üstteki öğeyi açın ve öğeyi yığındaki dizine alın. Bu, alt öğeyi yukarı çeker.
• - - Çıkar.
• O - Tamsayı olarak çıktı.
• /- IP'yi @, programı sonlandıran konumuna yönlendirir.

C #, 22 bayt

s=>s[s.Length-1]-s[0];

Test durumu ile birlikte tam kaynak kodu:

using System;

namespace StringCumulativeSlope
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,int>f= s=>s[s.Length-1]-s[0];
            Console.WriteLine(f("Hello World!"));
        }
    }
}

LINQ ile C #, 17 bayt

Hstde sayesinde LINQ kullanan daha kısa bir versiyon :

s=>s.Last()-s[0];

Ancak, ekstra bir ithalat gereklidir:

using System.Linq;

Ruby, 23 bayt

->s{s[-1].ord-s[0].ord}

Gibi bir değişkene ata f=->s{s[-1].ord-s[0].ord}ve beğenf["Hello World!"]

Dennis'in teleskopik seriler hakkındaki gözlemini kullanır.

retiküler, 12 bayt

idVc~@qVc-o;

Çevrimiçi deneyin!

Dennis'in gözlemini kullanarak yinelemeli bir süreci daha basit hale getirebiliriz.

idVc~@qVc-o;
i             take input
 d            duplicate
  V           pop input copy, push last character
   c          get its char code
    ~         put it under the input in the stack
     @q       reverse the item at the top of the stack
       V      get the last item of that (first item of input)
        c     convert to char
         -    subtract
          o   output
           ;  and terminate

Brain-Flak , 51 bayt

İçin kod 48 byte artı üç bayt -aASCII girişini sağlayan bayrak, (ancak ondalık çıkışı nasıl kullanışlı.:. D)

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

Çevrimiçi deneyin!

Bu olanlar biraz haha, benim diğer cevap daha sert ısırdı. İçinden geçelim.

{           While the top of the stack is nonzero:
 (            Push:
  [{}]          The top of the stack times negative one. Pop this off.
  ({})          Plus the value on top of the stack, which is duplicated to save for later.
  <>          On to the other stack
 )
 <>         Move back to the first stack
}
<>          After the loop, move back again.
{}          We have one extra element on the stack, so pop it
([]<>)      Push the height of the alternate stack back onto the first stack
{           While the top of the stack is nonzero:
 ({}[()])     Decrement this stack
 <>           Move back to the alternate stack
 ({}{})       Sum the top two elements
 <>           Move back tothe first stack
}
<>          Switch back to the stack holding the sum

05AB1E , 3 bayt

Ç¥O

Çevrimiçi deneyin!

CP-1252 kodlamasını kullanır.

açıklama

Ç       Converts input string to ASCII
¥       Compute difference between successive elements
O       Sum the result

Brachylog , 7 bayt

@c$)@[-

Çevrimiçi deneyin!

açıklama

@c        Convert "Hello World!" to [72,101,108,108,111,32,87,111,114,108,100,33]
  $)      Circular permute right: [33,72,101,108,108,111,32,87,111,114,108,100]
    @[    Take a prefix of the list
      -   Subtract

Çıkarma işlemi yalnızca iki tamsayıdan oluşan bir girdi için çalıştığından, seçilen önek bir kez başarılı olur [33, 72].

Haskell, 32 bayt

g=fromEnum
f t=g(last t)-g(t!!0)

R, 69 43 32 bayt

R'de olası bir çözümü sergilemenin eğlenceli olacağını düşündüğüm halde çok rakipsiz bir cevap.

sum(diff(strtoi(sapply(strsplit(readline(),"")[[1]],charToRaw),16L)))

Bu cevabın tek ilginç yönü kullanılmasıdır sapplyve charToRaw. Önce dizeyi ASCII tamsayı temsillerine dönüştürmek istediğim bir karakter vektörüne böldüm. charToRawFonksiyonu, R ve bunun yerine yukarıda belirtilen vektörü kullanımda her değer üzerinde döngü vektörlü değildir sapplyetkili bir şekilde işlev için vektör. Daha sonra 1. farkı ve sonra toplamı alın.

Düzenleme: charToRawBir dizeyi bir vektöre dönüştürür, burada her öğe her karakterin ham temsilidir, dolayısıyla kullanmaya gerek yoktur strsplitvesapply

sum(diff(strtoi(charToRaw(readline()),16)))

Edit2: Daha da iyi bir yol olduğu ortaya çıkıyor, fonksiyon utf8ToInt(x)tam olarak ne yapar , bu strtoi(charToRaw(x),16)da birkaç bayt tasarruf edebileceğimiz anlamına gelir (Fikir @ rturnbull'un başka bir soruya verdiği cevaptan alınmıştır ):

sum(diff(utf8ToInt(readline())))

Perl, 19 bayt

İçin +1 içerir -p

Son satırsonu olmadan STDIN'e girdi verin

echo -n "Hello World!" | slope.pl; echo

slope.pl:

#!/usr/bin/perl -p
$_=-ord()+ord chop

Giriş dizesinin en az 2 karakteri olduğundan eminseniz, bu 17 baytlık sürüm de çalışır:

#!/usr/bin/perl -p
$_=ord(chop)-ord

NodeJS, 82 bayt

x=process.argv[2],a=[],t=0;for(y in x)a[y]=x.charCodeAt(y),t+=y!=0?a[y]-a[y-1]:0

Açıklama:

x = process.argv[2] // Get the input
a=[], // Initializes an array to store the differences' values.
t=0;  // Initializes a variable to store the total of the differences
for(y in x) // Iterates over the string as an array of characters
    a[y]=x.charCodeAt(y) // Transforms the input into an array of integers
    t+=y!=0?a[y]-a[y-1]:0 // Add the difference of the last two characters, except at the first iteration

JavaScript, 79 bayt

f=x=>{a=[],t=0;for(y in x)a[y]=x.charCodeAt(y),t+=y!=0?a[y]-a[y-1]:0;return t}

Bağımsız değişken yerine işlev girdisi ile aynı fikir.

JavaScript ES6, 42 39 Bayt

f=
     s=>s[x='charCodeAt'](s.length-1)-s[x]();
;

console.log(f.toString().length);      // 39
console.log(f('Hello World!'))         // -39

Teleskop toplamları hakkında @Dennis gözlemini kullanma.

Bu durumda önemsiz çözümün en kısa olduğunu düşünüyorum.

charCodeAt@Neil tarafından önerilen tekrardan kurtularak 3 bayt kaydedildi .

Dördüncü, 28 bayt

: f depth 1- roll swap - . ;

Yığındaki karakterlerin bir listesini alır (Forth'un standart parametre alma yöntemi.) Karakterler, yığının üst kısmı dizenin ilk karakteri olacak şekilde alınır. Yığının altını üste taşır, değiştirir, sonra çıkarır ve yazdırırım. Çöp yığını üzerinde bırakılır ve çıktı stdout'a yazdırılır.

Her karakter ters sıra yerine sırayla itilmiş olsaydı, program 2 bayt daha kısa olurdu. Buna izin verilip verilmediğinden emin değilim, çünkü normalde argümanları ters sırada itersiniz.

Çevrimiçi deneyin

Şöyle denir:

33 100 108 114 111 87 32 111 108 108 101 72 f

Java, 42

int f(char[]c){return c[c.length-1]-c[0];}

Ungolfed:

  int f(char[] c) {
    return c[c.length - 1] - c[0];
  }

Açıklama:

Bu, teleskopla aynı prensibi kullanır:

sum =
  c[4] - c[3]
+        c[3] - c[2]
+               c[2] - c[1]
+                      c[1] - c[0]
= c[4]                      - c[0]

Herhangi bir uzunluktaki karakter dizisi için genelleştirilmiş nolan cevap, c[n-1] - c[0]ortadaki tüm öğelerin iptal edilmesidir.

PHP 7.1, 33 31 bayt

PHP 7.1'de uygulanan negatif dize ofsetlerini kullanır .

echo ord($argn[-1])-ord($argn);

Şu şekilde çalıştırın:

echo 'Hello World!' | php -nR 'echo ord($argn[-1])-ord($argn);';echo

Düzenlemeler

• Kullanarak 2 bayt kaydedildi $argn

RProgN , 142 Bayt, Rekabet Edemez

function tostack 'b' asoc stack 'a' asoc 0 'v' asoc b pop byte 'o' asoc b len while [ v o b pop byte ] 'o' asoc - + 'v' asoc b len end [ v end

Bu zorluğun keşfinden sonra 'tostack' komutu eklendiğinden (korkunç bir bayt sayısı olmasına rağmen) rekabet etmiyor

Test Durumları

Hello, World!
-39

Cool, huh?
-4

açıklama

function                        # Push the function between this and end to the stack
    tostack 'b' asoc            # Convert the implicit input to a stack, associate it with 'b'
    0 'v' asoc                  # Push 0 to the stack, associate it with 'v'
    b pop byte 'o' asoc         # Pop the top value of b (The end of the input), get the byte value, associate it with 'o'.
    b len                       # Push the size of b to the stack
    while [                     # While the top of the stack is truthy, pop the top of the stack
        v                       # Push v to the stack
            o                   # Push o to the stack
            b pop byte          # Pop the top value of b, push the byte value of that to the stack
            ] 'o' asoc          # Push a copy of the top of the stack, associate it with 'o'
            -                   # Subtract the top of the stack from one underneith that, In this case, the old value of o and the byte.
        +                       # Sum the top of the stack and underneith that, that is, the difference of the old value and new, and the total value
        'v' asoc                # Associate it with 'v'
        b len                   # Push the size of b to the stack (which acts as the conditional for the next itteration)
    end [                       # Pop the top of the stack, which will likely be the left over size of b
    v                           # Push the value of v to the top of the stack
end                             # Implicitely returned / printed

RProgN, Ters Lehçe Notasyonu düşünülerek üzerinde çalıştığım ezoterik bir dildir. Şu anda oldukça ayrıntılı, değişken ataması 4 karakter ve böyle, ancak gelecekte biraz sözdizim şekeri eklemeyi planlıyorum.

Ayrıca, RProgN, yığındaki bağımsız değişkenlere örtük olarak erişir ve bunları aynı şekilde döndürür. Program bittikten sonra yığınta kalan dize verileri örtülü olarak yazdırılır.

PHP, 36 bayt

<?=ord(strrev($s=$argv[1]))-ord($s);

• İlk ve son hariç her karakter birer kez eklenir ve çıkarılır.
  → farkların toplamı == ilk ve son karakter arasındaki fark
• ord()PHP bir dizenin ilk karakteri üzerinde çalışır
  → açıkça tek bir karaktere azaltmak gerek yok

Brain-Flak , 34 32 + 3 = 35 bayt

+3 -a, ascii modu için gerekli bayrak nedeniyle .

Çevrimiçi deneyin

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

Garip bir şekilde, ilk önce sondan çıkarmanın "hilesi" yerine spesifikasyonlarda kullanılan tanımın kullanılması daha etkilidir.

Bu tam olarak bunu yaparak çalışır.

(                           )  Push
 ([][()]){[{}]...([][()])}     While the stack has more than one item
  [{}]({})                     Subtract the top from a copy of the second
                          <>   Switch

CJam , 8 5 bayt

Dennis'e 3 bayt kaldıran iki öneri için çok teşekkürler

l)\c-

Çevrimiçi deneyin!

açıklama

Son değeri eksi ilk değeri hesaplar.

l        e# Read line as a string
 )       e# Push original string except last char, then last char
  \      e# Swap
   c     e# Convert to char: gives the first element of the string
    -    e# Subtract. Implicitly display

Haskell, 36 bayt

sum.(tail>>=zipWith(-)).map fromEnum

kullanımı:

Prelude> (sum.(tail>>=zipWith(-)).map fromEnum)"Hello World!"
-39

Haskell (Lambdabot), 31 bayt

sum.(tail>>=zipWith(-)).map ord

Zsh , 22 bayt

c=${1[-1]}
<<<$[#1-#c]

Çevrimiçi deneyin!

Aritmetik modda, #nameilk karakterin karakter kodunu alır name. cSon karaktere ayarladık ve ilk ve son kodlar arasındaki farkı alıyoruz.

Haskell , 30 bayt

(-).x.last<*>x.head
x=fromEnum

Çevrimiçi deneyin!

Son karakterin sıra değerini ilk karakterden çıkarır.

Haskell, 61 bayt

import Data.Char
f s=sum$g$ord<$>s
g(a:b:r)=b-a:g(b:r)
g _=[]

Java 7, 100 96 bayt

int c(String s){char[]a=s.toCharArray();int r=0,i=a.length-1;for(;i>0;r+=a[i]-a[--i]);return r;}

Test edilmemiş ve test kodu:

Burada deneyin.

class M{
  static int c(String s){
    char[] a = s.toCharArray();
    int r = 0,
        i = a.length-1;
    for(; i > 0; r += a[i] - a[--i]);
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("Hello World!"));
  }
}

Çıktı: -39

Clojure, 31 bayt

#(-(int(last %))(int(first %)))

Birisi görevi zaten tek bir operasyona indirdi.