एक चर लंबाई हैश लागू करें

Question

मेरे दोस्त और मेरे पास यह खेल है जिसे हम शब्दों के साथ खेलते हैं। यह एक मजेदार शगल है और इसमें एक शब्द में "रद्द करना" अक्षरों को शामिल किया गया है जब तक कि कुछ भी नहीं बचा है। मैं वास्तव में उससे बहुत ज्यादा तेज हूं, क्योंकि वह इसे लागू करना आपका काम है और मुझे अंत में उसे हरा देना है। जाहिर है, चूंकि मुझे कार्यक्रम को जितना संभव हो सके छिपाने के लिए आसान बनाना है, यह संभव के रूप में छोटा होना है।

यह खेल कैसे काम करता है?

खेल एक बहुत ही सरल एल्गोरिथ्म है। यह एक वर्णमाला स्ट्रिंग को कम कर देता है जब तक कि इसे किसी भी और कम नहीं किया जा सकता है, इस प्रकार यह एक प्रकार का हैश बना रहा है। वास्तविक खेल जिसे हम मनुष्य करते हैं, उसे लागू करना बहुत कठिन है, लेकिन इसे निम्नलिखित एल्गोरिथ्म में सरल बनाया जा सकता है:

आप वर्णमाला को आधे में मोड़कर शुरू करते हैं और इस तरह दो टुकड़ों को अस्तर करते हैं:

a b c d e f g h i j k l m
z y x w v u t s r p q o n

फिर, बीच से शुरू करते हुए, आप सकारात्मक पूर्णांक को शीर्ष आधा और नकारात्मक को नीचे तक असाइन करते हैं:

a  b  c  d  e f g h i j k l m
13 12 11 10 9 8 7 6 5 4 3 2 1

z   y   x   w   v  u  t  s  r  p  q  o  n
-13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

फिर आप अपना स्ट्रिंग लेते हैं (हम उपयोग कर रहे हैं hello world) और किसी भी गैर-वर्णानुक्रमिक वर्ण को अनदेखा करते हुए , इसका अनुवाद करें:

h e l l  o w   o  r  l d
6 9 2 2 -2 -10 -2 -5 2 10

फिर आप अक्षर मानों को जोड़ते हैं। पहले वाले चित्र (जैसे dऔर w, lऔर o) में पंक्तिबद्ध लोग इसे रद्द कर देंगे, जबकि अन्य जोड़ देंगे।

sum(6 9 2 2 -2 -10 -2 -5 2 10 )=12

12 के लिए संख्या है b, इसलिए हैश hello worldहैb

एक शब्द के लिए जो पूरी तरह से रद्द कर देता है (उदाहरण के लिए love), आप "0 वर्ण" का उत्पादन करते हैं -:। ध्यान दें कि इनपुट में, -अभी भी अवहेलना होगी। यह केवल आउटपुट में मायने रखता है।

यदि संख्या का परिमाण 13 से बड़ा है, तो आप दोगुना करना शुरू करते हैं aऔर z's' आप मूल रूप से संख्या में फिट होते हैं aया zजो कुछ भी हो उसे अंतिम अक्षर में छोड़ देते हैं:

code golf: 43.

फिट बैठता है 3 aऔर 4 छोड़ दिया है:

aaa 4: j
result: aaaj

संकेत: यह हिस्सा मूल रूप से divmodसिवाय इसके कि यह शून्य की ओर गोल है, न कि -infinity(जैसे -43 3 zका हो जाएगा और -4जो pऐसा है zzzp)।

नोट: पानी का छींटा यदि नहीं आती aहै या z'पूरी तरह से में फिट, केवल अगर यह ठीक है 0।

स्पष्टीकरण:

• हैश संवेदनशील में मामला है
• मानक Loopholes की अनुमति नहीं है
• I / O किसी भी प्रारूप में हो सकता है जो बहुत अधिक नहीं है, stdin, stdout, कमांड-लाइन arg, function आदि।
• यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा आकार ।

उदाहरण:

hello world  -->  b

love  -->  -

this is an example -->  aak

hello *&*(&(*&%& world  -->  b

good bye --> ae

root users --> zzs

Comments

loveखाली है ...

— जस्टिन

Answer 1

सीजेएम, 46 बाइट्स

इसे ऑनलाइन आज़माएँ , या ऑनलाइन परीक्षण सूट आज़माएँ ।

lel{'n-_W>+_zE<*}%:+{_De<C~e>___0>-'n+'-?o-}h;

व्याख्या

एल्गोरिथ्म काम करता है कि आप कैसे उम्मीद कर सकते हैं: इनपुट पढ़ें, लोअरकेस में कनवर्ट करें, प्रत्येक वर्ण को एक मूल्य पर मैप करें, मानों को योग करें, और अक्षरों को प्रिंट करें और योग को शून्य होने तक तदनुसार समायोजित करें। संभवतः सबसे दिलचस्प अनुकूलन (हालांकि यह केवल दो बाइट्स बचाता है) यह है कि इसके बजाय नकारात्मक चरित्र मैपिंग का उपयोग किया जाता है, क्योंकि यह मैपिंग मान को सही करने के लिए स्वैपिंग घटाव तर्कों से बचा जाता है जब मैप किए गए मूल्य की गणना करते हैं और एक पत्र के कारण वापस मैपिंग करते समय फिर से स्वैपिंग से बचते हैं। एक नकारात्मक मूल्य का घटाव इसके अलावा बदली जा रहा है।

lel             "Read a line of input and convert all letters to lowercase.";
{               "Map each character:";
  'n-_W>+         "Map each character to its negated value by subtracting 'n'
                   and incrementing if the result is nonnegative.";
  _zE<*           "If the value is out of the letter range, use 0 instead.";
}%
:+              "Compute the sum of the mapped character values.";
{               "Do...";
  _De<C~e>        "Compute the sum clamped to the letter range.";
  __              "If the clamped sum is nonzero, ...";
  _0>-'n+         "... then produce the clamped sum mapped back to a letter by
                     decrementing if it is positive and adding 'n', ...";
  '-              "... else produce '-'.";
  ?
  o               "Output the character produced above.";
  -               "Subtract the clamped sum out of the sum.";
}h              "... while the sum is nonzero.";
;               "Clean up.";

Answer 2

पायथ, 79 78 77 65 61 58

J+\-GK+0fTr13_14=ZsX@JzJKMe,pk*G/H13%H13@JxK?g\aZ>Z0_g\z_Z

Comments

आप शायद अधिक के @Jzबजाय का उपयोग कर सकते हैं f}YJz, लेकिन मुझे अब सोना चाहिए। गुड लक;)

— फ्राईअमईएग्गमैन

@FryAmTheEggman कूल, मैं के प्रतिच्छेदन के बारे में पता नहीं था @!

— orlp

Answer 3

क्लिप 10 , 87

Fr+`m[y?cAyg#Ay-v,-RRZ]0]}m.U`[Fx?x?<x0,:-/xR'z*m'm%xR!!%xR],:/xR'a*m'n%xR!!%xR]]'-[R13

Answer 4

आर, 258 बाइट्स

function(s){a=13;r=data.frame;z=strsplit(gsub("[^a-z]","",tolower(s)),"")[[1]];d=r(l=rev(letters),h=c(-1*a:1,1:a));m=merge(r(l=z),d);n=sum(m$h);q=abs(n);v=rep(ifelse(n>0,"a","z"),q%/%a);paste0(paste(v,collapse=""),d$l[d$h==sign(n)*q%%a],ifelse(n==0,"-",""))}

यह अब तक का सबसे स्थाई R कोड होना चाहिए। मुझे लगा कि आर एक सभ्य विकल्प हो सकता है क्योंकि इसमें सभी अक्षरों का एक वेक्टर "ए" "जेड" के माध्यम से एक अंतर्निहित वैश्विक चर के रूप में है। लेकिन यह पता चला है कि बाकी एक गड़बड़ है।

असंगठित + स्पष्टीकरण:

function(s) {
    a <- 13              # Store the value associated with a
    r <- data.frame      # Store the `data.frame` function

    # Split the input into a vector, ignoring case and non-letters
    z <- strsplit(gsub("[^a-z]", "", tolower(s)), "")[[1]]

    # Create a data frame where the first column is the letters
    # z through a and the second is the associated scores
    d <- data.frame(l=reverse(letters), h=c(-1*a:1, 1:a))

    # Merge the split vector with the data frame of scores
    m <- merge(data.frame(l=z), d)

    # Get the total score for the input
    n <- sum(m$h)
    q <- abs(n)

    # Pad the output with a or z as necessary
    v <- rep(ifelse(n > 0, "a", "z"), q %/% a)

    # Collapse the vector of a's or z's into a string
    out1 <- paste(v, collapse="")

    # Look up the letter associated with remainder
    out2 <- d$l[d$h == sign(n)*q%%a]

    # If n = 0, we still want a dash
    out3 <- ifelse(n == 0, "-", "")

    # Return the concatenation of all pieces of the output
    paste0(out1, out2, out3)
}

यह एक अनाम फ़ंक्शन ऑब्जेक्ट बनाता है जो इनपुट के रूप में एक स्ट्रिंग को स्वीकार करता है और संबंधित हैश मान को वापस करता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=function(s){...}।

उदाहरण:

> f("this is an example")
[1] "aak"

> f("root users")
[1] "zzs"

> f("love")
[1] "-"

> f("People like grapes.")
[1] "aaag"

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

प्रशन? मैं खुशी-खुशी कोई और स्पष्टीकरण दूंगा। सुझाव? सुझाव स्वागत से अधिक हैं!

Answer 5

हास्केल, 171 बाइट्स

import Data.Char
m=13
l=zip['a'..'z'][-i|i<-[-m..m],i/=0]
p 0="-"
p n|n>m='a':p(n-m)|n<(-m)='z':p(n+m)|1<2=[c|(c,i)<-l,i==n]
f n=p$sum[y|Just y<-[lookup(toLower x)l|x<-n]]

परीक्षण चालन:

> map f ["hello world", "love", "this is an example", "hello *&*(&(*&%& world", "good bye", "root users"]
["b","-","aak","b","ae","zzs"]

यह कैसे काम करता है: lअक्षरों से संबंधित मूल्य के लिए एक लुकअप तालिका है। इनपुट स्ट्रिंग से सभी वर्ण देखें और जो नहीं मिले, उन्हें त्यागें। परिणामी सूची का योग। योग pप्रिंट -या शायद पहले कुछ as या zs और अंत में (उल्टा) से पत्र देखने के आधार पर l।

Answer 6

आर - 200

function(s){l=letters
N=setNames
x=strsplit(tolower(s),'')[[1]]
n=(13:-13)[-14]
v=sum(N(n,l)[x[x%in%l]])
o=''
while(v){d=min(max(v,-13),13)
o=paste0(o,N(l,n)[as.character(d)])
v=v-d}
if(o=='')o='-'
o}

Comments

+1, निश्चित रूप से मेरे आर उत्तर से बेहतर है। अच्छा काम!

— एलेक्स ए।