大于小于大于大于可疑


45

给定的一个长度为N的字符串小于和大于号(<>),插入在所述开始和结束整数0至N和在每对的迹象,使得所有的不等式得到满足的之间。输出结果字符串。如果有多个有效输出,则输出其中任何一个(也只有一个)。

例如

<<><><<

有7个字符,因此必须插入0到7之间的所有数字。有效输出为

2<3<4>1<5>0<6<7

因为所有不等式一次都发生了

2<3
3<4
4>1
1<5
5>0
0<6
6<7

是真的。

如果需要,输出可以在符号周围有空格,例如2 < 3 < 4 > 1 < 5 > 0 < 6 < 7

以字节为单位的最短代码获胜。

测试用例

空行之后的第一行是输入,下一行是有效的输出示例。

[empty string]
0

<
0<1

>
1>0

<<
0<1<2

<>
1<2>0

><
1>0<2
2>0<1

>>
2>1>0

<<<
0<1<2<3

><>
1>0<3>2

>><
3>2>0<1
3>1>0<2
2>1>0<3

>>>
3>2>1>0

>>><<<
3>2>1>0<4<5<6
6>3>1>0<2<4<5
4>2>1>0<3<5<6
4>3>1>0<2<5<6

<<><><<
2<3<4>1<5>0<6<7

>><><>>
7>6>0<5>1<4>3>2

<<<<<<<<<<<<<<
0<1<2<3<4<5<6<7<8<9<10<11<12<13<14

>><<<<><>><><<
6>5>4<7<8<9<10>3<11>2>1<12>0<13<14
14>5>4<7<8<9<10>3<11>2>1<12>0<13<6

4
总是会有一个有效的输出吗?
mbomb007'9

3
@ mbomb007是的。总是至少有一个。
加尔文的爱好

23
我想看到有人在> <>中对此进行编程!那太棒了(我猜是讽刺的吗?)
Soren

这是一个非常有趣但简单的挑战,谢谢您
肖恩·怀尔德

Answers:


29

视网膜,20字节

字节数假定为ISO 8859-1编码。


$.'
S`>
%O#`\d+
¶
>

在线尝试!(第一行启用换行分隔的测试套件。)

说明

查找有效排列的一种简单方法是,先按顺序插入从0到的数字N,然后反转>s的每个子字符串周围的数字。以<><<>>><<为例:

0<1>2<3<4>5>6>7<8<9
  ---   -------      these sections are wrong, so we reverse them
0<2>1<3<7>6>5>4<8<9

即使我们真正可以使用的只是字符串,这两个任务在Retina中都非常简单。我们可以通过从N下往上插入数字0并反转周围的部分来节省额外的字节<,但是原理是相同的。

阶段1:替代


$.'

我们从将长度$'(后缀,即匹配的所有内容)插入输入中每个可能的位置开始。这会将数字从N向下插入0

阶段2:拆分

S`>

我们将输入>分成几行,因此每一行要么是一个单独的数字,要么是与相连的数字的列表<

第三阶段:排序

%O#`\d+

在每一行(%)中,我们O将数字(\d#)按其数值()进行排序(#)。由于我们按相反的数字顺序插入了数字,因此将它们反向。

阶段4:替代

¶
>

我们>再次换行,将所有内容重新合并为一行。而已。

附带说明一下,我一直想添加一种方法以应用于%换行符以外的其他定界符。如果我已经做到这一点,那么此提交将只有14个字节,因为那时后三个阶段将减少为一个阶段:

%'>O#`\d+

像我这样的大个子怎么样?辛苦了
ThreeFx

@ThreeFx因为我不使用蛮力。;)一分钟后解释。
Martin Ender

22

> <>46 43 35 + 4 for  -s== 39字节

0&l?!v:3%?\&:n1+$o!
+nf0.>&n; >l&:@

这是xnor算法在> <>中的实现。

它在堆栈上使用输入字符串(-s带有标准解释器的标志)。

您可以在在线解释器上试用。


2
> <>似乎是应对这一挑战的合适语言。
anaximander

21

> <>,26 + 4 = 30字节

l22pirv
1+$2po>:3%::2g:n$-

在线尝试!-s=标志为+4个字节-如果-s还可以(这意味着标志将需要完全删除以用于空输入),那么它将改为+3。

假定STDIN输入为空,因此i产生-1(在EOF上如此)。程序出错,尝试将此-1打印为字符。

使用最大数量的方法>,最小数量的<方法。

[Setup]
l22p         Place (length of stack) = (length of input) into position (2, 2) of
             the codebox. Codebox values are initialised to 0, so (0, 2) will
             contain the other value we need.
i            Push -1 due to EOF so that we error out later
r            Reverse the stack
v            Move down to the next line
>            Change IP direction to rightward

[Loop]
:3%          Take code point of '<' or '>' mod 3, giving 0 or 2 respectively
             (call this value c)
:            Duplicate
:2g          Fetch the value v at (c, 2)
:n           Output it as a number
$-1+         Calculate v-c+1 to update v
$2p          Place the updated value into (c, 2)
o            Output the '<' or '>' as a char (or error out here outputting -1)

干净退出且未对STDIN进行假设的程序是4个额外字节:

l22p0rv
p:?!;o>:3%::2g:n$-1+$2


11

Perl,29个字节

包括+2 -lp

使用STDIN上的输入运行,例如

order.pl <<< "<<><><<"

输出:

0<1<7>2<6>3<4<5

order.pl

#!/usr/bin/perl -lp
s%%/\G</?$a++:y///c-$b++%eg

说明

有两个计数器,最大值从字符串长度开始,最小值从0开始。然后在每个边界(包括字符串的开始和结尾)处(如果恰好在<最小值处放置该值,然后将其增加1),否则在最大值处将该值减小并减少乘以1(在字符串的末尾,无论哪个计数器都没有关系,因为它们都相同)


s{}{/\G/...}我以前从未见过,这很棒。
primo

10

Python 2,67个字节

f=lambda s,i=0:s and`i+len(s)*(s>'=')`+s[0]+f(s[1:],i+(s<'>'))or`i`

递归函数。通过将未使用的最小值满足依次对每个运营商xx<和最伟大的x>。最小的未使用值将存储在其中i并进行更新,最大的未使用值可从其i剩余长度中推断出来。


1
我认为您可以(s>'=')代替(s>='>')保存一个字节吗?
mathmandan '16

@mathmandan谢谢!奇怪的是<>它们不是连续的代码点。
xnor

同意!但是我想我可以看到=<和之间设置有意义>
mathmandan's

8

Python 2中,163个 137字节

from random import*
def f(v):l=len(v)+1;N=''.join(sum(zip(sample(map(str,range(l)),l),v+' '),()));return N if eval(N)or len(v)<1else f(v)

随机播放数字,直到语句等于True

试试吧。


显然,这是所有答案中最明智的。
moopet

7

APL,33个字节

⍞←(S,⊂''),.,⍨-1-⍋⍋+\0,1-2×'>'=S←⍞

⍋⍋ 非常有用。

说明

⍞←(S,⊂''),.,⍨-1-⍋⍋+\0,1-2×'>'=S←⍞
                                   ⍞ read a string from stdin      '<<><><<'
                                 S←   store it in variable S
                             '>'=     test each character for eq.   0 0 1 0 1 0 0
                         1-2×         1-2×0 = 1, 1-2×1 = ¯1         1 1 ¯1 1 ¯1 1 1
                                      (thus, 1 if < else ¯1)
                       0,             concatenate 0 to the vector   0 1 1 ¯1 1 ¯1 1 1
                     +\               calculate its running sum     0 1 2 1 2 1 2 3
                   ⍋                 create a vector of indices    1 2 4 6 3 5 7 8
                                      that sort the vector in
                                      ascending order
                 ⍋                   do it again: the compound ⍋⍋ 1 2 5 3 6 4 7 8
                                      maps a vector V to another
                                      vector V', one permutation of
                                      the set of the indices of V,
                                      such that
                                            V > V  => V' > V'.
                                             i   j     i    j
                                      due to this property, V and V'
                                      get sorted in the same way:
                                          ⍋V = ⍋V' = ⍋⍋⍋V.
              -1-                     decrement by one              0 1 4 2 5 3 6 7
      ⊂''                            void character vector         ⊂''
    S,                                concatenate input string     '<<><><<' ⊂''
   (     ),.,⍨                       first concatenate each        0 '<' 1 '<' 4 '>' 2 \
                                     element of the result vector  '<' 5 '>' 3 '<' 6 '<' \
                                     with the cordisponding        7 ⊂''
                                     element in the input string,
                                     then concatenate each result
⍞←                                  write to stdout

3
圣诞树(⍋⍋)有什么作用?
科纳·奥布莱恩

升级,按排序顺序返回索引。通过执行两次,您可以获得1最小的数字2所在的位置,下一个最小的数字所在的位置等。
Zwei

@ ConorO'Brien编辑并附有简短说明。
Oberon'9

是的,很短。
科纳·奥布莱恩

7

JavaScript(ES6),74 56字节

s=>s.replace(/./g,c=>(c<'>'?j++:l--)+c,j=0,l=s.length)+j

从数字集开始0...N。在每个阶段,只需取剩余数中的最大(l)或最小(j)即可;根据定义,下一个数字必须小于或大于该数字。编辑:感谢@Arnauld,节省了大量18字节。


3
你可以用replace吗?也许s=>s.replace(/./g,c=>(c<'>'?j++:l--)+c,j=0,l=s.length)+j
Arnauld

@Arnauld ...而且我认为我的第一次尝试(不能接受replace)减少到74字节时表现不错……
Neil

5

Pyth-19个字节

万岁比较链!

!QZhv#ms.idQ.p`Mhl

在线评估安全性无效。


4

2sable,20 字节

gUvy'<Qi¾¼ëXD<U}y}XJ

说明

gU                     # store input length in variable X
  v              }     # for each char in input
   y'<Qi               # if current char is "<"
        ¾¼             # push counter (initialized as 0), increase counter
          ëXD<U}       # else, push X and decrease value in variable X
                y      # push current char
                  XJ   # push the final number and join the stack

在线尝试!

对于N <10,这可能是14个字节:

ÎvyN>}J'<¡í'<ý

4

C#,102 99字节

string f(string s){int i=0,j=s.Length;var r="";foreach(var c in s)r=r+(c<61?i++:j--)+c;return r+i;}

取消高尔夫:

string f(string s)
{
    int i = 0, j = s.Length;    // Used to track the lowest and highest unused number.
    var r = "";                 // Start with the empty string.

    foreach (var c in s)        // For each character in the input string:
        r = r +                 // Append to the result:
            (c < 61             // If the current character is '<':
                ? i++           // Insert the lowest unused number,
                : j--)          // otherwise, insert the highest unused number.
            + c;                // And append the current character.

    return r + i;               // Return the result with the last unused number appended.
}

我很累,所以我可能会丢失一些东西,但是不将r = r +零件更改为复合分配会节省几个字节吗?
Carcigenicate's

2
否- r+右侧部分告诉编译器整个内容是一个字符串,因此使用的字符串表示形式c。如果我使用r+=,则?:零件将评估为int,的顺序值c将被添加到这一点,只然后将它转换为它的字符串表示。
Scepheo

4

Java的8,126个是125字节

s->{int t=s.replaceAll("<","").length(),y=t-1;String r=t+++"";for(char c:s.toCharArray())r+=(c+"")+(c<61?t++:y--);return r;};

我不认为这行得通

非高尔夫测试程序

public static void main(String[] args) {
    Function<String, String> function = s -> {
        int t = s.replaceAll("<", "").length(), y = t - 1;
        String r = t++ + "";
        for (char c : s.toCharArray()) {
            r += (c + "") + (c < 61 ? t++ : y--);
        }
        return r;
    };

    System.out.println(function.apply("<<><><<"));
    System.out.println(function.apply(">>><<<"));
    System.out.println(function.apply(">>>"));
    System.out.println(function.apply("<<<"));
    System.out.println(function.apply(">><><>>"));
}

您可以将更.replaceAll改为.replace并删除括号,(c+"")以节省5个字节。
凯文·克鲁伊森

@KevinCruijssen大约5个字节还没有哈哈。
肖恩·怀德(Shaun Wild)

使用正确的高尔夫语言时,第5位和第2位之间的差是5个字节。使用Java,这是到目前为止的最后一个和最后一个之间的区别。
肖恩·维尔德(Shaun Wild)

Java几乎总是在最后遇到代码挑战,但是我们之所以发布Java答案的原因是为了尽可能地缩短编写代码的乐趣。如果Java代码的字节数从500扩展到499,我个人已经很高兴。; P
Kevin Cruijssen

我们基本上忽略所有超越竞争对手,只是与竞争或Java / C#意见书等。
肖恩野

4

果冻27 14 12 字节

@Martin Enders的港口 CJam解决方案的
-2字节,感谢@Dennis

żJ0;µFṣ”<Uj”<

TryItOnline上进行测试

怎么样?

żJ0;Fṣ”<Uj”< - main link takes an argument, the string, e.g. ><>
 J           - range(length(input)), e.g. [1,2,3]
  0          - literal 0
   ;         - concatenate, e.g. [0,1,2,3]
ż            - zip with input, e.g. [[0],">1","<2",">3"]
    F        - flatten, list, e.g. "0>1<2>3"
      ”<  ”< - the character '<'
     ṣ       - split, e.g. ["0>1","2>3"]
        U    - upend (reverse) (implicit vectorization), e.g. ["1>0","3>2"]
         j   - join, e.g. "1>0<3>2"

先前的方法在数学上很有趣,但并非如此。

=”>U
LR!×ÇĖP€S‘
L‘ḶŒ!ị@ÇðżF

这使用阶乘基本系统来找到满足等式的[0,N]的排列索引。


1
U向量化,因此您不需要żJ0;保存另一个字节。
丹尼斯

4

Clojure中,152个 132 126字节

(defn f[s](loop[l 0 h(count s)[c & r]s a""](if c(case c\<(recur(inc l)h r(str a l c))(recur l(dec h)r(str a h c)))(str a l))))

通过消除尽可能多的空格,节省了大量字节。我意识到,不必将括号与另一个字符分开。

基本上是@Scepheo的答案的Clojure端口。完全相同。

那些recur电话真是杀手!我想我本可以用原子来清理它。swap!使用原子添加到count所需调用:/

感谢@amalloy为我节省了一些字节。

取消高尔夫:

(defn comp-chain [chain-str]
  (loop [l 0 ; Lowest number
         h (count chain-str) ; Highest number
         [c & cr] chain-str ; Deconstruct the remaining list
         a ""] ; Accumulator
    (if c ; If there's any <>'s left
      (if (= c \<) ; If current char is a <...
        (recur (inc l) h cr (str a l c)) ; Add l to a, and inc l
        (recur l (dec h) cr (str a h c))) ; Add h to a, and dec h
      (str a l)))) ; Add on the remaining lowest number, and return

欢迎光临本站!
DJMcMayhem

@DJMcMayhem谢谢。希望下次我能够提出自己的解决方案,而不仅仅是移植另一个答案。
Carcigenicate's

您可以在loop绑定之前s和之后再保存两个空格a。您也可以通过更换刮了一下if同一株树case(case c \< (recur ...) nil (str ...) (recur ...))。当然cr也可以简称。
amalloy

@amalloy好点,谢谢。我上笔记本电脑时会更新。
Carcigenicate's

3

Haskell,162个字节

import Data.List
(a:b)%(c:d)=show c++a:b%d
_%[x]=show x
f l=map(l%).filter(l#)$permutations[0..length l]
(e:f)#(x:y:z)=(e!x)y&&f#(y:z)
_#_=0<1
'>'!x=(>)x
_!x=(<)x

这很长。


3

Perl(107 + 1 for -p)108

for$c(split''){$s.=$i++.$c;}
for$b(split'<',$s.$i){$h[$j]=join'>',reverse split'>',$b;$j++;}
$_=join'<',@h;

Martin Ender♦的答案盗取了算法


2

Ruby,135个字节

g=gets
puts g.nil?? 0:[*0..s=g.size].permutation.map{|a|a.zip(g.chars)*""if s.times.map{|i|eval"%s"*3%[a[i],g[i],a[i+1]]}.all?}.compact

注意:时间复杂度很大(O(n!))。


2

Python 2中,176个 172字节

与其他人相比,它不是很短,但是我很高兴能够如此迅速地解决它。

from itertools import*
def f(s):
 for p in permutations(range(len(s)+1)):
    n=list(s);p=list(p);t=[p.pop()]+list(chain(*zip(n,p)));r="".join(map(str,t))
    if eval(r):return r

在线尝试

取消高尔夫:

from itertools import*
def f(s):
    n=list(s);R=range(len(s)+1)
    for p in permutations(R):
        p=list(p)
        r=[p.pop()]
        t=n+p
        t[::2]=n
        t[1::2]=p
        r="".join(map(str,r+t))
        if eval(r):return r

在线尝试


隔行扫描的部分可以做得更短一些zip
-Maltysen

@Maltysen不会短很多,因为列表的长度不一样(我仍然要pop),但是要短一些。如果是N<10,我可以缩短字串化的时间。
mbomb007

1

PHP,190字节

随机洗牌直到找到有效的解决方案

$x=range(0,$l=strlen($q=$argv[1]));while(!$b){$b=1;$t="";shuffle($x);for($i=0;$i<$l;){$t.=$x[$i].$q[$i];if(($q[$i]==">"&$x[$i]<$x[$i+1])|($q[$i]=="<"&$x[$i]>$x[1+$i++]))$b=0;}}echo$t.$x[$i];

381字节获取所有解决方案并选择一种

<?php $d=range(0,strlen($q=$argv[1]));echo $q."\n";$e=[];function f($t=""){global$e,$d,$q;foreach($d as$z){preg_match_all("#\d+#",$t,$y);if(in_array($z,$y[0]))continue;$p=preg_match_all("#[<>]#",$t);$g="";if(preg_match("#\d+$#",$t,$x)){if(($q[$p]==">"&$x[0]<$z)|($q[$p]=="<"&$x[0]>$z))continue;$g=$q[$p];}strlen($q)==$p+1|!$q?$e[]=$t.$g.$z:f($t.$g.$z);}}f();echo$e[array_rand($e)];
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.