Maior que menor que maior que algo suspeito


45

Dada uma cadeia N de comprimento menor que e maior que sinais ( <, >), insira os números inteiros de 0 a N no início e no final e entre cada par de sinais, para que todas as desigualdades sejam atendidas. Saída da string resultante. Se houver várias saídas válidas, produza qualquer uma (e apenas uma) delas.

Por exemplo

<<><><<

possui 7 caracteres, portanto, todos os números de 0 a 7 inclusive devem ser inseridos. Uma saída válida é

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

porque todas as desigualdades tomadas uma de cada vez

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

são verdadeiras.

Se desejado, a saída pode ter espaços ao redor dos sinais, por exemplo 2 < 3 < 4 > 1 < 5 > 0 < 6 < 7.

O código mais curto em bytes vence.

Casos de teste

A primeira linha após uma linha vazia é a entrada e as próximas linhas são exemplos de saída válidos.

[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
Sempre haverá uma saída válida?
Mbomb007

3
@ mbomb007 Sim. Sempre há pelo menos um.
Hobbies de Calvin

23
Eu quero ver alguém programar isso em> <>! Isso seria fantástico (e irônico eu acho?)
Soren

Este foi um desafio realmente divertido, mas simplesmente, obrigado op
Shaun Wild

Respostas:


29

Retina , 20 bytes

A contagem de bytes assume a codificação ISO 8859-1.


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

Experimente online! (A primeira linha permite um conjunto de testes separado por avanço de linha.)

Explicação

Uma maneira simples de encontrar uma permutação válida é começar inserindo os números de 0para Nem ordem e, em seguida, reverter os números ao redor de cada substring de >s. Tome <><<>>><<como exemplo:

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

Ambas as tarefas são bastante simples na Retina, mesmo com as quais podemos realmente trabalhar com strings. Podemos salvar um byte adicional inserindo os números de Nbaixo para cima 0e revertendo as seções ao redor <, mas o princípio é o mesmo.

Etapa 1: Substituição


$.'

Começamos inserindo o comprimento de $'(o sufixo, ou seja, tudo após a partida) em todas as posições possíveis na entrada. Isso insere os números de Nbaixo para 0.

Etapa 2: Divisão

S`>

Dividimos a entrada >em linhas separadas, para que cada linha seja um número individual ou uma lista de números unidos <.

Etapa 3: classificação

%O#`\d+

Dentro de cada linha ( %), ordenamos ( O) os números ( \d#) pelo seu valor numérico ( #). Como inserimos o número na ordem numérica reversa, isso os reverte.

Etapa 4: Substituição

¶
>

Transformamos os feeds de linha >novamente para juntar tudo de volta em uma única linha. É isso aí.

Como uma observação lateral, pretendo adicionar uma maneira de aplicar %a outros delimitadores que não sejam feeds de linha. Se eu já tivesse feito isso, esse envio teria sido de 14 bytes, porque os três últimos estágios seriam reduzidos a um único:

%'>O#`\d+

Como é isso como um oitavo do meu tamanho? Bom trabalho.
ThreeFx 6/09/16

@ThreeFx Porque eu não uso força bruta. ;) Explicação chegando em um minuto.
Martin Ender


21

> <> , 26 + 4 = 30 bytes

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

Experimente online! +4 bytes para o -s=sinalizador - se -sestiver tudo bem (isso significaria que o sinalizador precisaria ser descartado inteiramente para entrada vazia), então seria +3.

Supõe que a entrada STDIN esteja vazia e iproduz -1 (o que ocorre no EOF). O programa erro ao tentar imprimir este -1 como um caractere.

Usa a abordagem max-de-nums-até-longe-para >-min-de-nums-até-longe <.

[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)

Um programa que sai corretamente e não assume o STDIN é de 4 bytes extras:

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

12

CJam , 16 bytes

l_,),.\'</Wf%'<*

Experimente online!

Um porto da minha resposta Retina .

Explicação

l    e# Read input.
_,   e# Duplicate, get length N.
),   e# Get range [0 1 2 ... N].
.\   e# Riffle input string into this range.
'</  e# Split around '<'.
Wf%  e# Reverse each chunk.
'<*  e# Join with '<'.

11

Perl, 29 bytes

Inclui +2 para -lp

Execute com entrada no STDIN, por exemplo

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

Resultado:

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

order.pl:

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

Explicação

Tenha dois contadores, max começando com o comprimento da string, min começando com 0. Então, em cada limite (incluindo o início e o fim da string), se for um pouco antes de <colocar o mínimo lá e aumentar em 1, caso contrário, coloque o máximo lá e diminua por 1 (no final da sequência, não importa qual contador você tome, pois ambos são iguais)


s{}{/\G/...}Eu nunca vi isso antes, é brilhante.
Primo

10

Python 2, 67 bytes

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

Uma função recursiva. Satisfaz cada operador, por sua vez, colocando o menor valor não utilizado xpara a x<maior e mais para x>. O menor valor não utilizado é armazenado ie atualizado, e o maior valor não utilizado é deduzido ie o comprimento restante.


1
Eu acho que você poderia fazer em (s>'=')vez de (s>='>')salvar um byte?
mathmandan 9/09/16

@mathmandan Thanks! É estranho isso <e >não são pontos de código consecutivos.
xnor

Acordado! Mas acho que posso ver como faria sentido ter =entre <e >.
mathmandan

8

Python 2, 163 137 bytes

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)

Embaralha os números até que a instrução avance para True.

Tente.


Essa é claramente a mais sensata de todas as respostas.
moopet 8/09/16

7

APL, 33 bytes

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

⍋⍋ é extraordinariamente útil.

Explicação

⍞←(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
O que as árvores de Natal ( ⍋⍋) fazem?
Conor O'Brien

é grau, que retorna as indicações na ordem classificada. Ao fazer isso duas vezes, você obtém 1onde estava o menor número, 2onde estava o próximo número menor, etc.
Zwei

@ ConorO'Brien editado com uma breve explicação.
Oberon

Sim, muito curto ._.
Conor O'Brien

7

JavaScript (ES6), 74 56 bytes

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

Começa com o conjunto de números 0...N. Em cada estágio, basta pegar o maior ( l) ou o mínimo ( j) dos números restantes; o próximo número deve, por definição, ser menor ou maior que isso. Edit: salvou um enorme 18 bytes graças a @Arnauld.


3
Você pode usar replace? Talvezs=>s.replace(/./g,c=>(c<'>'?j++:l--)+c,j=0,l=s.length)+j
Arnauld

@Arnauld ... e eu pensei que eu estava fazendo bem para golf minha primeira tentativa (que não era passível de substituição por replace) até 74 bytes ...
Neil

5

Pitão - 19 bytes

Viva a comparação!

!QZhv#ms.idQ.p`Mhl

Não funciona on-line, por segurança de avaliação.


4

2sable , 20 bytes

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

Explicação

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

Experimente online!

Para N <10, isso poderia ter sido 14 bytes:

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

4

C #, 102 99 bytes

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

Ungolfed:

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

Estou cansado, então poderia estar faltando alguma coisa, mas mudar a r = r +peça para uma tarefa composta economizaria alguns bytes?
Carcigenicate

2
Não - a r+parte do lado direito informa ao compilador que a coisa toda é uma string, portanto a representação de string cé usada. Se eu usasse r+=, a ?:parte seria avaliada como an int, o valor ordinal de cseria adicionado a isso e só então seria convertido em sua representação de string.
Scepheo 7/09/16

4

Java 8, 126 125 bytes

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

Eu acho que isso nem funciona hehe

Programa de teste ungolfed

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

Você pode alterar .replaceAllpara .replacee remover os parênteses (c+"")para economizar 5 bytes.
Kevin Cruijssen 8/09/16

@KevinCruijssen Não gerou cerca de 5 bytes hahah.
Shaun Wild

Ao usar um idioma de golfe adequado, 5 bytes é a diferença entre o 5º e o 2º lugar. Com java, é a diferença entre o último lugar de longe e apenas o último lugar.
Shaun Wild

O Java quase sempre será o último dos desafios do código de golfe, mas o motivo pelo qual postamos as respostas do Java é para a diversão de escrevê-lo o mais breve possível. Pessoalmente, já estou feliz se meu código Java passar de 500 para 499 em termos de byte. ; P
Kevin Cruijssen

Nós basicamente ignorar tudo sobre os concorrentes e apenas competir com ou Java / C # submissões etc ..
Shaun selvagem

4

Geléia , 27 14 12 bytes

Porto da solução CJam @Martin Enders
-2 bytes graças a @Dennis

żJ0;µFṣ”<Uj”<

Teste em TryItOnline

Quão?

ż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"

O método anterior era interessante matematicamente, mas não tão ...

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

Isto usa o sistema de base fatorial para encontrar um índice das permutações de [0, N] que satisfarão a equação.


1
Uvetoriza, assim você não precisa . żJ0;salva outro byte.
Dennis

4

Clojure, 152 132 126 bytes

(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))))

Economizei um número razoável de bytes, eliminando o máximo de espaço em branco possível. Percebi que espaço em branco não é necessário para separar um parêntese de outro caractere.

Basicamente, uma porta Clojure da resposta do @ Scepheo. Funciona de forma idêntica.

Essas recurchamadas são assassinas! Suponho que poderia ter usado átomos para limpá-lo. As swap!chamadas necessárias para usar átomos adicionados à contagem: /

Agradeço a @amalloy por me salvar alguns bytes.

Ungolfed:

(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

Bem vindo ao site!
DJMcMayhem

@DJMcMayhem Thanks. Espero que da próxima vez seja capaz de criar minha própria solução, em vez de apenas apresentar outra resposta.
Carcigenicate

Você pode salvar mais dois espaços na loopligação, antes se depois a. Você também pode raspar um pouco, substituindo a ifárvore com um case: (case c \< (recur ...) nil (str ...) (recur ...)). E, claro, crpoderia ser um nome mais curto.
amalloy

@amalloy Bons pontos, obrigado. Vou atualizar quando chegar no meu laptop.
Carcigenicate 09/09/16

3

Haskell, 162 bytes

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

Isso é muito longo.


3

Perl (107 + 1 para -p) 108

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

Algoritmo roubado da resposta de Martin Ender ♦


2

Ruby, 135 bytes

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

Nota: A complexidade do tempo é grande (O (n!)).


2

Python 2, 176 172 bytes

Não é muito curto comparado aos outros, mas estou feliz por ter resolvido isso tão rapidamente.

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

Experimente online

Ungolfed:

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

Experimente online


a parte interlace prolly pode ser muito mais curto feito atravészip
Maltysen

@ Maltysen Nem uma tonelada menor, porque as listas não são do mesmo tamanho (eu ainda preciso pop), mas é um pouco menor. Se N<10eu pudesse reduzir a rigidez.
mbomb007

1

PHP, 190 bytes

aleatória até que exista uma solução válida

$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 bytes, obtenha todas as soluções e escolha uma

<?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)];
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.