新密码提示：Word-walker

23

我想到了一种生成密码的新方法，尽管从长远来看它可能不太聪明，但它仍然可以成为有趣的代码高尔夫。

使用一串字，将生成密码：

  • 在第n个单词中选择第n个字符
  • 如果n大于单词，则继续倒计数

例：

This is a fun task!
T     s a  u      !

T是第一个字符
s是第二
个字符a是第一个字符，但来回移动它也是第三个字符
u是第二个字符，但由于倒数，它也是第四个字符
“！” 是“任务”中的第五个字符！因此将包含在最终密码中，Tsau!

规则

  • 输入将是一个字符串
  • 用空格分隔字符串，必须包含所有其他字符
  • 大写字母必须保持大写，小写字母相同
  • 您在每个单词中执行n步，其中n是之前的单词数加1
  • 如果n大于单词，则必须向后移动单词，如果按了开始，则再次前进，直到您踩了n次
  • 第一个字符和最后一个字符仅跨过一次，因此在第七个位置上的“ fun”以“ funufun”为例，以n结尾，而不是“ funnuff”，以f结尾
  • 输出必须是字符串

例子：

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 
— Troels MB Jensen
source
3
to是长字符串中的第12个字（0索引），因此代码字母应为t，而不是o。
— 尼尔，
@Neil <s>序列是1索引的，否则您不能以第一个单词的第一个字母开头</ s>（我尝试过）我的错，我现在看到了
— Troels MB Jensen
14
Tsau!是中文的Fuck!
— sergiol
1
同样，您选择funfun而不是funnuff的步进计划将增加输出中元音的百分比。从密码学上来说，这不是一个强大的密码生成器。
— Criggie '18
1
@Criggie我从没打算使用它，但是正如我所说，这将带来一个有趣的挑战，而且似乎高尔夫球手也同意
— Troels MB Jensen

Answers:

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
— 艾米尼亚
source
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));}

通过创建@ user71546的JavaScript答案端口，感谢@SamYonnou -31个字节。再次 感谢@ SamYonnou，-4个字节优化了Java算法。

在线尝试。

说明：

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)
— 凯文·克鲁伊森
source
对于测试用例0、2和5
— 无效-TF
1
类似于user71546的版本似乎在打高尔夫球到117，“使用更多的算术方法”：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

我不经常使用Slice的最后一个参数。

— 尼尔
source
我喜欢木炭使用剪刀字形
— 约拿（Jonah）
3

JavaScript（Node.js），78 70 69 68字节

-1字节@Arnauld

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
— 浅香诗人
source
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
]
— 加伦·伊万诺夫（Galen Ivanov）
source
1

Pyth，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
— ok
source
1

Japt -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
— 毛茸茸
source
1

C（gcc），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]);}

在线尝试！

— 埃里克·F
source
-(j>1)-1+~(j>1)我认为可以用少1个字节代替。
— Shieru Asakoto
106个字符：putchar( t[ j=strlen(t)-1, k = i++ % (j ? j*2 : 1), k<j ? k : j+j-k ]); 在线尝试！
— user5329483
缓冲版本：全局变量隐式清零。替换*u++为c[i]并卸下u。
— user5329483
建立在@ user5329483 105字节上
— ceilingcat '18
1

AWK，79个字节

主要是因为我很好奇看到任何更好的awk或bash解决方案！

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

在线尝试！

— 约拿
source
1

Haskell，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字节感谢@B。梅塔

— 妮米
source
看起来zipWith(\i w->(cycle$id<>reverse.drop 1.init$w)!!i)[0..].words也可以。
— user28667
1
您可以通过更改lambda来保存另一个字节，以\i->(!!i).cycle.(id<>reverse.drop 1.init)排除显式w提及（TIO）
— B. Mehta，
1

Stax，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

运行这个

— 递归的
source
1

PHP，77字节

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

在线尝试！

  • -3字节感谢Kevin
  • -10字节，多亏了Titus
— 用户名
source
1
好答案！一个小的事情高尔夫：你可以通过改变摆脱支架和一个额外的第三个字节foreach(...){$c=...;echo$c[...];}来foreach(...)echo($c=...)[...];。在线尝试：87个字节
— Kevin Cruijssen
您可以使用参数列表自动拆分为单词（-8个字节），并.=保存两个字节：while(ord($w=$argv[++$i]))echo($w.=strrev(substr($w,1,-1)))[~-$i%strlen($w)]; 在线尝试
— Titus，
真好！一个问题：〜-$ i与（$ i-1）一样，对吗？
— user2803033
0

的powershell 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++})}

取消高尔夫： 

$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++})}
— 彼得·范迪维尔
source
1
您可以在此处缩短很多内容。您是否了解在PowerShell中打高尔夫球的技巧？
— briantist
谢谢！我曾考虑过在发布后立即使用switch，但是其余的事情还没有发生在我身上。
— 彼得·范迪维尔
同样，这里的一个实际问题是，您实际上并未在此代码段中的任何地方进行输入。对于编写程序或函数，我们非常灵活，但是您具有隐式输入。第一步，您可以简单地将其替换""|%{为$args|%{，但我认为您也可以更有效地打高尔夫球；）
— briantist
1
这是TIO中的演示，还演示了如何对测试用例使用arguments功能。仅保留代码的代码块，还可以让您在帖子中使用TIO的简单链接和字节数！
— briantist
0

J，43个字节

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

不打高尔夫球

[: (> {~"_1 #@> | i.@#) [: (, }.@}:)&.> [: <;._1 ' '&,
  • <;._1 ' '&, 在空格上分割
  • (, }.@}:)&.> 对于每个单词，杀死第一个和最后一个榆树，然后附加到单词上
  • #@> | i.@# 将每个单词的剩余长度除以其索引
  • > {~"_1 取得结果并从每个单词中挑选出来。

在线尝试！

— 约拿
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.