Tôi đã nghĩ ra một cách mới để tạo mật khẩu của mình và mặc dù về lâu dài có lẽ nó không thông minh lắm, nhưng nó vẫn có thể tạo ra một môn đánh gôn vui nhộn.

Lấy một chuỗi các từ, mật khẩu được tạo ra như vậy:

• Chọn ký tự thứ n trong từ thứ n
• Nếu n lớn hơn từ, tiếp tục đếm ngược

Thí dụ:

This is a fun task!
T     s a  u      !

T là ký tự đầu tiên
s là ký tự thứ hai
a là ký tự đầu tiên, nhưng qua lại nó cũng là
u thứ ba là thứ hai nhưng vì đếm ngược nên nó cũng là thứ tư
'!' là nhân vật thứ năm trong 'nhiệm vụ!' và do đó sẽ được bao gồm trong mật khẩu cuối cùng,Tsau!

Quy tắc

• Đầu vào sẽ là một chuỗi
• Phân tách chuỗi trên khoảng trắng, tất cả các ký tự khác phải được bao gồm
• Chữ in hoa phải viết hoa, giống với chữ thường
• Bạn thực hiện n bước trong mỗi từ, trong đó n là số lượng từ đã đến trước cộng với một từ
• Nếu n lớn hơn từ, bạn phải lùi lại qua từ, nếu bạn nhấn bắt đầu, bạn lại tiếp tục cho đến khi bạn đã bước n lần
• Nhân vật đầu tiên và cuối cùng chỉ được bước một lần, vì vậy, 'vui vẻ' ở vị trí thứ bảy như một ví dụ là 'funufun' và kết thúc vào n, không phải là 'funnuff' và kết thúc trên f
• Đầu ra phải là một chuỗi

Ví dụ:

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

Mã ngắn nhất tính bằng byte thắng!

Python 2 , 72 byte

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

Hãy thử trực tuyến!

05AB1E , 11 byte

#vyN©Fû}®è?

Hãy thử trực tuyến!

Giải trình

#             # 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

Thạch , 12 byte

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

Hãy thử trực tuyến!

Java 10, 148 117 114 110 byte

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 byte nhờ @SamYonnou bằng cách tạo một cổng câu trả lời JavaScript của @ user71546 .
-4 byte nhờ @SamYonnou một lần nữa, tối ưu hóa thuật toán cho Java.

Hãy thử trực tuyến.

Giải trình:

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)

Than , 16 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

  Ｓ                 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

Tôi không thường xuyên sử dụng tham số cuối cùng của Slice.

JavaScript (Node.js) , 78 70 69 68 byte

-1 byte @Arnauld

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

Hãy thử trực tuyến!

Giải trình

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

Màu đỏ , 135 byte

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]

Hãy thử trực tuyến!

Có thể đọc được

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
]

Perl 5 , 76 byte

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

Hãy thử trực tuyến!

k , 31 30 28 byte

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

Hãy thử trực tuyến!

Bình thường , 12 byte

s.e@+b_Ptbkc

Dùng thử trực tuyến

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

Japt -P, 11 byte

¸Ëê ŪD gEÉ

Thử nó

¸Ë+s1J w)gE

Thử nó

Giải thích

¸Ëê Ū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

C (gcc) , 148 byte (phiên bản chuỗi), 114 byte (phiên bản in)

Nếu tôi phải trả về một chuỗi (phiên bản dài):

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

Hãy thử trực tuyến!

Mặt khác, tôi chỉ in và không lo lắng về bộ đệm (phiên bản ngắn):

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

Hãy thử trực tuyến!

AWK, 79 byte

Chủ yếu là vì tôi tò mò muốn xem bất kỳ giải pháp awk hoặc bash tốt hơn!

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

Hãy thử trực tuyến!

C # (.NET Core) , 111 byte

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

Hãy thử trực tuyến!

Haskell, 65 62 61 byte

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

Hãy thử trực tuyến!

Nó đòi hỏi phiên bản mới nhất Preludecó tính <>năng.

                   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  

Chỉnh sửa: -3 byte nhờ @ user28667, -1 byte nhờ @B. Mehta

Stax , 9 byte

éñ~╗D¡┤Gq

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

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

Chạy cái này

PHP , 77 byte

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

Hãy thử trực tuyến!

• -3 byte nhờ Kevin
• -10 byte nhờ Tít

Powershell 208 186 170 byte

$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++})}

Ung dung:

$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++
    })
}

Kiểm tra các trường hợp dưới đây hoặc thử trực tuyến

@(
    "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++})}

J, 43 byte

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

vô dụng

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

• <;._1 ' '&, chia trên không gian
• (, }.@}:)&.> cho mỗi từ, giết cây du đầu tiên và cuối cùng và nối vào từ
• #@> | i.@# lấy phần còn lại của mỗi từ được chia thành chỉ mục của nó
• > {~"_1 lấy kết quả đó và gảy nó từ mỗi từ.

Hãy thử trực tuyến!