23

मैंने अपने पासवर्ड बनाने के लिए एक नया तरीका सोचा, और भले ही यह लंबे समय में बहुत चालाक नहीं है, फिर भी यह एक मजेदार कोड-गोल्फ बना सकता है।

शब्दों की एक स्ट्रिंग लेते हुए, पासवर्ड इस प्रकार उत्पन्न होता है:

Nth शब्द में nth वर्ण चुनें
यदि n शब्द से बड़ा है, तो पीछे की ओर गिनती जारी रखें

उदाहरण:

This is a fun task!
T     s a  u      !

T पहला अक्षर
s है दूसरा
a a पहला है, लेकिन आगे पीछे जा रहा है और यह तीसरा
u भी दूसरा है लेकिन पीछे की ओर गिनने के कारण यह चौथा भी है
! ' 'कार्य' में पाँचवाँ चरित्र है! और इस प्रकार अंतिम पासवर्ड में शामिल किया जाएगा,Tsau!

नियम

इनपुट एक स्ट्रिंग होगा
रिक्त स्थान को स्ट्रिंग को अलग करें, अन्य सभी वर्णों को शामिल किया जाना चाहिए
अपरकेस अक्षरों को अपरकेस के साथ ही रहना चाहिए
आप प्रत्येक शब्द में n कदम उठाते हैं, जहाँ n शब्दों की संख्या है जो प्लस वन से पहले आए हैं
यदि n शब्द से बड़ा है, तो आपको शब्द के माध्यम से पीछे की ओर कदम रखना चाहिए, यदि आप प्रारंभ से टकराते हैं, तो आप फिर से आगे बढ़ते हैं जब तक कि आपके पास n समय नहीं है
पहला और अंतिम चरित्र केवल एक बार ही चलता है, इसलिए सातवें स्थान पर 'मज़ा' एक उदाहरण के रूप में 'फनफुन' जाता है और n पर समाप्त होता है, न कि 'फ़नफ' और अंत में समाप्त होता है
आउटपुट एक स्ट्रिंग होना चाहिए

उदाहरण:

Input              Output
Once Upon A Time   OpAe
There was a man    Taaa
Who made a task    Waak
That was neat!     Taa
This is a long string to display how the generator is supposed to work  Tsagnoyotoipto

बाइट्स में सबसे छोटा कोड जीतता है!

code-golf string

— ट्रॉल्स एमबी जेनसेन
स्रोत

3

toलंबी स्ट्रिंग में 12 वां शब्द (0-अनुक्रमित) है, और इसलिए कोड अक्षर होना चाहिए t, नहीं o।

— नील

@ नील <s> अनुक्रम 1-अनुक्रमित है, अन्यथा आप पहले अक्षर के साथ शुरू नहीं कर सकते हैं पहला शब्द </ s> (मैंने कोशिश की) मेरा बुरा है, मैं इसे अब देखता हूं

— ट्रॉल्स एमबी जेन्सेन

14

Tsau!के लिए चीनी हैFuck!

— sergiol

1

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

— क्रिग्गी

1

@ क्रिगी मैं इसका उपयोग करने का कभी इरादा नहीं करता था, लेकिन जैसा कि मैंने कहा, यह एक मजेदार चुनौती के लिए बनायेगा, और ऐसा प्रतीत होता है कि गोल्फर्स सहमत हैं

— ट्रोल्स एमबी जेन्सेन

13

पायथन 2 , 72 बाइट्स

lambda s:''.join((-~i*(w+w[-2:0:-1]))[i]for i,w in enumerate(s.split()))

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

— TFeld
स्रोत

7

05AB1E , 11 बाइट्स

#vyN©Fû}®è?

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

व्याख्या

#             # split input on spaces
 vy           # for each word in input
   N©F        # N times do, where N is the current iteration
      û}      # palendromize the word
        ®è    # use N to index into the resulting word
          ?   # print

— Emigna
स्रोत

4

जेली , 12 बाइट्स

ḲJị"ŒBṖȯ$€$Ɗ

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

— आउटगोल्फर को एरिक करें
स्रोत

4

जावा 10, 148 117 114 110 बाइट्स

s->{int i=-1,j;for(var a:s.split(" "))System.out.print(a.charAt((j=a.length()-1)>0*i++?i/j%2<1?i%j:j-i%j:0));}

-31 बाइट्स @ यूजर 71546 के जावास्क्रिप्ट उत्तर का पोर्ट बनाकर @SamYonnou को धन्यवाद । -4 बाइट्स धन्यवाद @SamYonnou के लिए फिर से, जावा के लिए एल्गोरिथ्म का अनुकूलन।

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

स्पष्टीकरण:

s->{                            // Method with String parameter and no return-type
  int i=-1,                     // Step integer, starting at -1
      j;                        // Temp integer
  for(var a:s.split(" "))       // Loop over the parts split by spaces
    System.out.print(           // Print:
     a.charAt((j=a.length()-1)  //  Set `j` to the the length of the part minus 1
               >0               //  If the length of the part is larger than 1 (`j` > 0)
                 *i++?          //  (and increase `i` by 1 in the process with `i++`)
                i/j%2<1?        //   If `i` integer-divided by `j` is even:
                 i%j            //    Print the character at index `i` modulo-`j`
                :               //   Else:
                 j-i%j          //    Print the character at index `j` minus `i` modulo-`j`
               :                //  Else:
                0));}           //   Print the first (and only) character
                                //   (the >0 check is added to prevent divided-by-0 errors)

— केविन क्रूज़सेन
स्रोत

परीक्षण के मामलों 0, 2 और 5 के लिए काम नहीं करता है

— TFeld

1

117 से नीचे "एक अधिक अंकगणितीय दृष्टिकोण का उपयोग करते हुए" उपयोगकर्ता 71546 के संस्करण के समान प्रतीत होता है:s->{int i=-1,j;for(var a:s.split(" ")){System.out.print(a.charAt(++i>(j=a.length()-1)?j>0?i/j%2==0?i%j:j-i%j:0:i));}}

— SamYonnou

1

@SamYonnou धन्यवाद! और मैं कोष्ठक को हटाने और बदलने के ==0लिए तीन और बाइट्स को गोल्फ करने में सक्षम रहा हूं <1।

— केविन क्रूज़सेन

1

++i>(j=a.length()-1)हालत से छुटकारा पाने के लिए 110 को गोल्फ से बाहर कर दिया क्योंकि गणित उस स्थिति के परिणाम की परवाह किए बिना उसी तरह से काम करता है:s->{int i=-1,j;for(var a:s.split(" "))System.out.print(a.charAt(0<(j=a.length()+i-++i)?i/j%2<1?i%j:j-i%j:0));}

— SamYonnou

1

@SamYonnou फिर से धन्यवाद! मैं थोड़ा बदल दिया है 0<(j=a.length()+i-++i)?करने के लिए (j=a.length()-1)>0*i++?(कोई बाइट तो फिर भी कर सहेजे) तो स्पष्टीकरण प्रकार के थोड़ा आसान था।

— केविन क्रूज़सेन

3

चारकोल , 16 बाइट्स

⭆⪪Ｓ §⁺ι✂ι±²¦⁰±¹κ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

  Ｓ                 Input string
 ⪪                  Split on spaces
⭆                   Map over words and join
      ι ι           Current word
       ✂ ±²¦⁰±¹     Slice backwards from 2nd last character to start exclusive
     ⁺              Concatenate
    §          κ    Cyclically index on current word index
                    Implicitly print

मुझे अक्सर स्लाइस के अंतिम पैरामीटर का उपयोग करने के लिए नहीं मिलता है।

— नील
स्रोत

मुझे पसंद है कि चारकोल एक कैंची ग्लिफ़ का उपयोग करता है

— जोना

3

जावास्क्रिप्ट (Node.js) , 78 70 69 68 बाइट्स

-1 बाइट @ अरनौल

x=>x.split` `.map((y,i)=>y[a=i%(l=y.length-1)|0,i/l&1?l-a:a]).join``

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

व्याख्या

x=>
 x.split` `                    // Split the words by spaces
 .map((y,i)=>                  // For each word:
  y[                           //  Get the character at index:
                               //   A walk has cycle of length (2 * y.length - 2)
   a=i%(l=y.length-1)|0,       //   Calculate index a = i % (y.length - 1)
   i/l&1                       //   Check in which half the index i in
   ?l-a                        //   If in the second half of cycle, use y.length - 1 - a
   :a                          //   If in the first half of cycle, use a                  
  ]
 ).join``                      // Join back the letters

— शायरु असकोतो
स्रोत

2

लाल , 135 बाइट्स

func[s][n: 0 p: copy""foreach w split s" "[append/dup r: copy""append w
reverse copy/part next w back tail w n: n + 1 append p r/(n)]p]

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

पठनीय:

f: func[s][
    n: 0
    p: copy ""
    foreach w split s "  "[
        r: copy ""
        append/dup r append w reverse copy/part next w back tail w n: n + 1
        append p r/(n)
    ]
    p
]

— गैलेन इवानोव
स्रोत

2

पर्ल 5 , 76 बाइट्स

print map{$l=length;substr$_.reverse,$i++%(2*$l-2||1)*(1+1/$l),1}split" ",<>

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

— fockjef
स्रोत

2

के , 31 30 28 बाइट्स

{x{*|y#x,1_|1_x}'1+!#x}@" "\

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

— zgrep
स्रोत

|-1_->1_|

— ngn

आप आंतरिक लैम्ब्डा के तर्कों को स्वैप करके 2 बाइट्स बचा सकते हैं

— ngn 3'18

1

पायथ , 12 बाइट्स

s.e@+b_Ptbkc

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

s.e@+b_PtbkcQ   Final Q (input) implicit

           cQ   Split on spaces
 .e             Map the above with b=element, k=index
       Ptb        Remove 1st and last character
      _           Reverse
    +b            Prepend the unaltered element ('abcd' -> 'abcdcb')
   @      k       Get the kth character (0 indexed, wrapping)
s               Join on empty string, implicit output

— सोक
स्रोत

1

जाप,, `-P`11 बाइट्स

¸Ëê ÅªD gEÉ

कोशिश करो

¸Ë+s1J w)gE

कोशिश करो

स्पष्टीकरण

¸Ëê ÅªD gEÉ
¸               :Split on spaces
 Ë              :Map over each element D at index E
  ê             :  Palindromise
    Å           :  Slice off the first character
     ªD         :  Logical OR with the original element (the above will return an empty string for single character words)
        g       :  Get the character at index
         EÉ     :  E-1

¸Ë+s1J w)gE
¸               :Split on spaces
 Ë              :Map over each element D at index E
   s1J          :  Slice off the first and last characters
       w        :  Reverse
  +     )       :  Append to D
         gE     :  Get the character at index E

— झबरा
स्रोत

1

सी (जीसीसी) , 148 बाइट्स (स्ट्रिंग संस्करण), 114 बाइट्स (प्रिंट संस्करण)

अगर मुझे एक स्ट्रिंग (लंबा संस्करण) वापस करना होगा:

char c[99]={0};char*f(s,t,u,i,j,k)char*s,*t,*u;{for(u=c,i=0;t=strtok(s," ");s=0,i++)*u++=t[j=strlen(t),k=2*j-(j>1)-1,(i%k<j?i%k:k-i%k)%j];return c;}

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

अन्यथा, मैं सिर्फ प्रिंट करता हूं और बफर के बारे में चिंता नहीं करता (लघु संस्करण):

f(s,t,i,j,k)char*s,*t;{for(i=0;t=strtok(s," ");s=0,i++)putchar(t[j=strlen(t),k=2*j-(j>1)-1,(i%k<j?i%k:k-i%k)%j]);}

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

— ErikF
स्रोत

-(j>1)-1+~(j>1)मुझे लगता है कि 1 बाइट कम के साथ प्रतिस्थापित किया जा सकता है।

— शायरु असकोतो

106 वर्ण: putchar( t[ j=strlen(t)-1, k = i++ % (j ? j*2 : 1), k<j ? k : j+j-k ]); इसे ऑनलाइन आज़माएं!

— user5329483

बफ़र्ड संस्करण: वैश्विक चर अनुमानित रूप से शून्य हैं। यू के *u++साथ बदलें c[i]और निकालें।

— user5329483

बिल्डिंग @ user5329483 105 बाइट्स

— सीलिंगकैट

1

AWK, 79 बाइट्स

ज्यादातर क्योंकि मैं किसी भी बेहतर awk या बैश समाधान देखने के लिए उत्सुक हूँ!

{for(i=1;i<=NF;i++){l=length($i);k=int(i/l)%2?l-i%l:k%l;printf substr($i,k,1)}}

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

— जोनाह
स्रोत

1

सी # (.NET कोर) , 111 बाइट्स

s=>{int i=-1,j;return String.Concat(s.Split(' ').Select(a=>a[++i>(j=a.Length-1)?j>0?i/j%2<1?i%j:j-i%j:0:i]));};

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

— Vadim
स्रोत

PPCG में आपका स्वागत है। अच्छा जवाब

— मुहम्मद सलमान

1

हास्केल, 65 62 61 बाइट्स

zipWith(\i->(!!i).cycle.(id<>reverse.drop 1.init))[0..].words

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

इसके लिए नवीनतम संस्करण की आवश्यकता होती है, Preludeजो <>कार्य करता है।

                   words    -- split the input string into a list of words
zipWith(\i->     )[0..]     -- zip the elements i of [0..] and the words pairwise
                            -- with the function      
      ... <> ...            --   call the functions with a word and concatenate
                            --   the results. The functions are
        id                  --     id: do nothing
        reverse.drop 1.init --     drop last and first element and reverse
    cycle                   --   repeat infinitely
(!!i)                       -- take the ith elemnt of

संपादित करें: -3 बाइट्स @ user28667 के लिए धन्यवाद, -1 बाइट थैंक्स टू @ बी। मेहता

— nimi
स्रोत

लगता है zipWith(\i w->(cycle$id<>reverse.drop 1.init$w)!!i)[0..].wordsकाम भी करता है।

— user28667

1

आप \i->(!!i).cycle.(id<>reverse.drop 1.init)स्पष्ट wउल्लेख (TIO)

— बी मेहता

1

स्टैक्स , 9 बाइट्स

éñ~╗D¡┤Gq

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

j       split into words
{       start block for mapping
  cDrD  copy word; remove first and last character; reverse
  +     concatenate with original word
  i@    modularly (wrap-around) index using map iteration index
m       perform map

इसको चलाओ

— पुनरावर्ती
स्रोत

1

PHP , 77 बाइट्स

while(ord($w=$argv[++$i]))echo($w.=strrev(substr($w,1,-1)))[~-$i%strlen($w)];

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

-3 बाइट्स केविन की बदौलत
टाइटस को -10 बाइट्स धन्यवाद

— user2803033
स्रोत

1

अच्छा जवाब! गोल्फ के लिए एक छोटी सी बात: आप बदल कर कोष्ठक और एक अतिरिक्त तीसरे बाइट से छुटकारा मिल सकता है foreach(...){$c=...;echo$c[...];}के लिए foreach(...)echo($c=...)[...];। इसे ऑनलाइन आज़माएँ: 87 बाइट्स

— केविन क्रूज़सेन

आप स्वचालित रूप से शब्दों (-8 बाइट्स) में विभाजित करने के लिए तर्क सूची का उपयोग कर सकते हैं, और .=दो बाइट्स बचाता है: while(ord($w=$argv[++$i]))echo($w.=strrev(substr($w,1,-1)))[~-$i%strlen($w)]; इसे ऑनलाइन आज़माएं

— टाइटस

अच्छा! एक प्रश्न: ~ - $ i जैसा ($ i-1) करता है, ठीक है?

— user2803033

0

पॉवरशेल 208 186 170 बाइट्स

$args|%{$i=0;-join($_.Split()|%{$l=($b=($a=$_)).Length;if($l-gt2){$b=($a|%{-join$a[($l-2)..1]})}for($j=0;$a.Length-le$i;$j++){$a+=($b,$_)[$j%2]}$a.Substring($i,1);$i++})}

Ungolfed:

$args|%{
   $i=0;
    -join($_.Split()|%{
        $l=($b=($a=$_)).Length;
        if($l-gt2){
            $b=($a|%{-join$a[($l-2)..1]})
        }
        for($j=0;$a.Length-le$i;$j++){
            $a+=($b,$_)[$j%2]
        }
        $a.Substring($i,1);
        $i++
    })
}

नीचे दिए गए मामलों की जांच करें या इसे ऑनलाइन आज़माएं

@(
    "This is a fun task!",
    "Once Upon A Time",
    "There was a man",
    "Who made a task",
    "That was neat",
    "This is a long string to display how the generator is supposed to work"
)|%{$i=0;-join($_.Split()|%{$l=($b=($a=$_)).Length;if($l-gt2){$b=($a|%{-join$a[($l-2)..1]})}for($j=0;$a.Length-le$i;$j++){$a+=($b,$_)[$j%2]}$a.Substring($i,1);$i++})}

— पीटर वांडिवियर
स्रोत

1

यहां बहुत कुछ है जिसे आप यहां छोटा बना सकते हैं। क्या आपने PowerShell में गोल्फ के लिए युक्तियाँ देखी हैं ?

— रिश्वतखोर

धन्यवाद! मैंने पोस्ट करने के बाद स्विच का उपयोग करने के बारे में सोचा था, लेकिन बाकी सब मेरे लिए अभी तक नहीं हुआ था।

— पीटर वैंडिविएर

यहां एक वास्तविक समस्या यह भी है कि आप इस स्निपेट में कहीं भी इनपुट नहीं लेते हैं। हम प्रोग्राम या फ़ंक्शन लिखने में सक्षम होने के बारे में बहुत लचीले हैं, लेकिन आपके पास अंतर्निहित इनपुट है। पहले कदम के रूप में आप बस अपने ""|%{साथ बदल सकते हैं $args|%{, लेकिन मुझे लगता है कि आप इसे और भी प्रभावी ढंग से गोल्फ कर सकते हैं;)

— बेरिंटिस्ट

1

यहाँ TIO में एक प्रदर्शन है जो यह भी दिखाता है कि परीक्षण मामलों के लिए तर्क सुविधा का उपयोग कैसे करें । अपने कोड के लिए कोड ब्लॉक रखने के साथ ही आप अपने पोस्ट के लिए TIO की आसान लिंकिंग और बाइट काउंट का उपयोग करते हैं!

— रिश्वतखोर

0

जे, 43 बाइट्स

[:(>{~"_1#@>|i.@#)[:(,}.@}:)&.>[:<;._1' '&,

ungolfed

[: (> {~"_1 #@> | i.@#) [: (, }.@}:)&.> [: <;._1 ' '&,

<;._1 ' '&, रिक्त स्थान पर विभाजित
(, }.@}:)&.> प्रत्येक शब्द के लिए, पहले और अंतिम एल्म को मारें और शब्द को जोड़ दें
#@> | i.@# प्रत्येक शब्द की लंबाई के शेष को अपने सूचकांक में विभाजित करें
> {~"_1 उस परिणाम को लें और इसे प्रत्येक शब्द से हल करें।

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

— जोनाह
स्रोत

नया पासवर्ड आइडिया: वर्ड-वॉकर

पायथन 2 , 72 बाइट्स

05AB1E , 11 बाइट्स

जेली , 12 बाइट्स

जावा 10, 148 117 114 110 बाइट्स

चारकोल , 16 बाइट्स

जावास्क्रिप्ट (Node.js) , 78 70 69 68 बाइट्स

लाल , 135 बाइट्स

पठनीय:

पर्ल 5 , 76 बाइट्स

के , 31 30 28 बाइट्स

पायथ , 12 बाइट्स

जाप,, -P11 बाइट्स

स्पष्टीकरण

सी (जीसीसी) , 148 बाइट्स (स्ट्रिंग संस्करण), 114 बाइट्स (प्रिंट संस्करण)

AWK, 79 बाइट्स

सी # (.NET कोर) , 111 बाइट्स

हास्केल, 65 62 61 बाइट्स

स्टैक्स , 9 बाइट्स

PHP , 77 बाइट्स

पॉवरशेल 208 186 170 बाइट्स

जे, 43 बाइट्स

ungolfed

जाप,, `-P`11 बाइट्स