Sua própria instrução "para"

Supondo que você tenha a seguinte entrada: a, b, c, d

A entrada pode estar em uma linha usando qualquer formato "a / b / c / d" ou "a, b, c, d" etc.

Você também pode ter 4 entradas.

Você deve codificar o seguinte comportamento (pseudo-código aqui):

var i = <a>
while (i <b> <c>)
    print i
    i = i + <d>
    print "\n"

Aqui estão alguns casos de testes:

input : 1,<,10,1
output :
1
2
3
4
5
6
7
8
9

Mais um :

input : 20,>,10,1
output :
20
21
22
23
24
25
26
27
...
infinite loop / program crashes

• aé um número inteiro , o valor inicial de i.

• bé uma string ou um char , não pode ser outra coisa, o comparador usado na condição final do forloop.

  bpode e deve ser uma das seguintes strings:

  - ">"
  - "<"
  

• cé um número inteiro , o número usado na condição final do for loop.

• dé um número inteiro que é adicionado a i em cada loop.

Este é o código-golfe, a resposta mais curta ganha!

JavaScript (ES6),  44  43 56 bytes

Economizou 1 byte graças ao ETHproductions
Edit: corrigido para atender aos requisitos de saída

(a,b,c,d)=>{for(s='';eval(a+b+c);a+=d)s+=a+`
`;alert(s)}

Teste

let f =

(a,b,c,d)=>{for(s='';eval(a+b+c);a+=d)s+=a+`
`;alert(s)}

f(1,'<',7,2)

Javascript (ES6), 47 42 48 bytes

Queria fazer a versão for, mas alguém foi mais rápido, então aqui está a versão recursiva.

(b,c,d)=>F=a=>eval(a+b+c)&&console.log(a)|F(a+d)

Você precisa adicionar f=antes e chamá-lo como f(b,c,d)(a).

Muito obrigado a Arnauld pelo golfe incrível.

alertalterado para console.logpor causa da especificação de saída

Festa pura, 35

Eu suponho que está OK apenas para conectar os parâmetros no loop for padrão:

for((i=$1;i$2$3;i+=$4));{ echo $i;}

Experimente online .

Gelatina , 12 bytes

Ṅ+⁶µ⁴;⁵¹vµ¿t

Experimente online!

O Jelly tem várias maneiras de fazer iterações, criar intervalos, etc. Mas, espelhar o comportamento do C ++ exatamente é bastante difícil, devido a casos especiais como o incremento sendo 0, o loop terminando antes de iniciar (devido à desigualdade ao contrário) ) e o incremento indo na direção errada (o que significa que a condição de saída do loop não pode ser atendida naturalmente). Como tal, essa solução é basicamente uma tradução direta do C ++, embora isso o torne um nível mais baixo do que normalmente é um programa Jelly. Felizmente, o C ++ tem um comportamento indefinido no estouro de número inteiro assinado (a pergunta usa int), o que significa que um programa pode fazer qualquer coisa nesse caso e, portanto, não há necessidade de tentar imitar o comportamento do estouro.

Explicação

Ṅ+⁶µ⁴;⁵¹vµ¿t
   µ     µ¿   While loop; while ((⁴;⁵¹v) counter) do (counter = (Ṅ+⁶)counter).
    ⁴;⁵       Second input (b) appended to third input (c), e.g. "<10"
        v     Evaluate, e.g. if the counter is 5, "<10" of the counter is true
       ¹      No-op, resolves a parser ambiguity
Ṅ             Output the counter, plus a newline
 +⁶           Add the fourth input (d)
           t  Crashes the program (because the counter is not a list)

Falhando no programa é a maneira mais concisa de desativar a saída implícita do Jelly (caso contrário, ele produziria o valor final do contador); ele gera várias mensagens de erro no stderr, mas normalmente consideramos isso permitido.

Aliás, o contador do loop é inicializado com o valor atual antes do loop iniciar. Como o loop aparece no início do programa, essa será a primeira entrada.

Python 2 , 50 bytes

a,b,c,d=input()
while eval(`a`+b+`c`):print a;a+=d

Experimente online!

R, 63 bytes

function(a,b,c,d)while(do.call(b,list(a,c))){cat(a,"\n");a=a+d}

Java, 58 bytes

(a,b,c,d)->{for(;b>61?a>c:a<c;a+=d)System.out.println(a);}

05AB1E , 22 20 bytes

[D²`'>Q"‹›"è.V_#D,³+

Experimente online!

Explicação

[                       # start loop
 D                      # copy top of stack (current value of a)
  ²`                    # push b,c to stack
    '>Q                 # compare b to ">" for equality
       "‹›"             # push this string
           è            # index into the string with this result of the equality check
            .V          # execute this command comparing a with c
              _#        # if the condition is false, exit loop (and program)
                D,      # print a copy of the top of the stack (current value of a)
                  ³+    # increment top of stack (a) by d

SmileBASIC, 53 bytes

INPUT A,B$,C,D
S=ASC(B$)-61WHILE S*A>S*C?A
A=A+D
WEND

Explicação:

INPUT A,B$,C,D
IF B$=="<" THEN S=-1 ELSE S=1 'get comparison direction
I=A
WHILE S*I>S*C 'loop while I is less than/greater than the end
 PRINT I
 INC I,D
WEND

Isso usa o fato de que X<Yé o mesmo que-X>-Y

Empilhados , 34 bytes

@d@c@b[show d+][:c b tofunc!]while

Experimente online! (Teste incluído.) Essa é uma função que espera que a pilha se pareça com:

a b c d

Por exemplo:

1 '<' 10 2
@d@c@b[show d+][:c b tofunc!]while

Explicação

@d@c@b[show d+][:c b tofunc!]while
@d@c@b                               assign variables
               [............]while   while:
                :c                   duplicate "i" and push c
                   b tofunc!         convert b to a function and execute it
      [.......]                      do:
       show                          output "i" without popping
            d+                       and add the step to it

C ++, 80

Opa, isso C++não é C. Fiquei um pouco confuso com a pergunta.

void f(int a,char b,int c,int d){for(;b==62?a>c:a<c;a+=d)cout<<a<<endl;}

C, 52 51 bytes

-1 byte graças a H Walters

f(a,b,c,d){for(;b&2?a>c:a<c;a+=d)printf("%d\n",a);}

Experimente online!

Python 3, 52 bytes

def f(a,b,c,d):
 while[a>c,a<c][b<'>']:print(a);a+=d

repl.it

Pip , 14 bytes

W Va.b.ca:d+Pa

Leva quatro argumentos de linha de comando. Suporta números de ponto flutuante e negativo e operadores de comparação < > = <= >= !=. Experimente online!

                a,b,c,d are cmdline args
W               While loop with the following condition:
  Va.b.c          Concatenate a,b,c and eval
            Pa  Print a with newline (expression also returns value of a)
        a:d+    Add d to that and assign back to a

Geléia , 8 bytes

ḢṄ+⁹;µV¿

Esse é um link diádico que leva a, b, c como argumento à esquerda ed como seu argumento à direita. A saída pode ser infinita e vai para STDOUT.

Experimente online!

Como funciona

ḢṄ+⁹;µV¿  Dyadic link.
          Left argument:  a,b,c (integer, character, integer)
          Right argument: d     (integer)

       ¿  While...
      V     the eval atom applied to a,b,c returns 1:
     µ       Combine the links to the left into a chain and apply it to a,b,c.
Ḣ              Head; pop and yield a from a,b,c.
 Ṅ             Print a, followed by a linefeed.
  +⁹           Add a and the right argument (d) of the dyadic link.
    ;          Concatenate the result and the popped argument of the chain,
               yielding a+d,b,c.

Python 2 , 45 bytes

exec"i=%d\nwhile i%c%d:print i;i+=%d"%input()

Experimente online!

Uma implementação muito literal da especificação. Pega o modelo de código, substitui as entradas por formatação de string e o executa.

TeX simples, 88 bytes

\newcount\i\def\for#1 #2 #3 #4 {\i#1\loop\the\i\endgraf\advance\i#4\ifnum\i#2#3\repeat} 

O comando \forfornece a função solicitada. Salve isso for.texe, em seguida, execute-o e insira os valores das variáveis ​​na linha de comandos: pdftex '\input for \for 1 < 5 1 \bye'Os valores das variáveis ​​devem ser separados por espaços.

Python 3, 61 bytes

Um forro:

e=input;exec(f'i={e()}\nwhile i{e()}{e()}:print(i);i+={e()}')

Haskell , 66 64 bytes

f a b c d|last$(a<c):[a>c|b>"<"]=print a>>f(a+d)b c d|1<3=pure()

Experimente online! Uso:

Prelude> f 0 "<" 9 2
0
2
4
6
8

Bash (+ Ferramentas Unix), 29 bytes

Golfe

bc<<<"for(x=$1;x$2$3;x+=$4)x"

Teste

./forloop 1 '<' 10 1
1
2
3
4
5
6
7
8
9

Ruby, 43 41 bytes

->a,*i,d{a=d+p(a)while eval"%s"*3%[a,*i]}

Se bpode ser recebido como um símbolo Ruby em vez de uma string, você obtém 38 bytes :

->a,b,c,d{a=d+p(a)while[a,c].reduce b}

Experimente qualquer uma das soluções online!

Lisp comum, 82 80 79 73 64 bytes

(defmacro f(a b c d)`(do((i,a(+ i,d)))((not(,b i,c)))(print i)))

Teste

(f 1 < 10 1)

1 
2 
3 
4 
5 
6 
7 
8 
9 
NIL
CL-USER> 

-9 bytes graças a PrzemysławP.

PHP, 69 65 bytes

for(list(,$i,$b,$c,$d)=$argv);$b<"="?$i<$c:$i>$c;$i+=$d)echo"$i
";

Execute com '-r'; fornecer argumentos de linha de comando como entrada.

Por apenas um byte a mais 4 bytes, posso usar todos os operadores:

for(list(,$i,$b,$c,$d)=$argv;eval("return $i$b$c;");$i+=$d)echo"$i
";

Sim, avaliação do mal. Você sabia que isso pode retornar algo?

A desestruturação abreviada [,$i,$b,$c,$d]=$argv;economizaria mais 4 bytes;
mas o PHP 7.1 pós-desafio.

Perl 6 , 44 bytes

{.say for $^a,*+$^d...^*cmp$^c!= $^b.ord-61}

Como funciona

{                                          }  # A lambda.
          $^a                                 # Argument a.
             ,*+$^d                           # Iteratively add d,
                   ...^                       # until (but not including the endpoint)
                       *cmp$^c                # the current value compared to c
                                              # (less=-1, same=0, more=1)
                              != $^b.ord-61.  # isn't the codepoint of the b minus 61.
 .say for                                     # Print each number followed by a newline.

Se não há problema em retornar uma sequência (potencialmente infinita) de números como um valor do tipo Seq, em vez de imprimir os números no stdout, a .say forpeça pode ser removida, reduzindo-a para 35 bytes.

Clojure, 66 63 bytes

#(when((if(= %2"<")< >)% %3)(println %)(recur(+ % %4)%2 %3 %4))

-3 bytes fatorando o loop. Estou "abusando" do parâmetro init para atuar como acumulador em execução.

Solução recursiva (com TCO). Veja os comentários no código pré-escrito. Tentei uma solução recursiva não-TCO e ela acabou sendo de 67 bytes.

Eu adoraria ver essa batida em Clojure! Eu acho que este é o menor que posso conseguir.

(defn my-for [init-num com-str com-num inc-num]
  (let [op (if (= com-str "<") < >)] ; Figure out which operator to use
    (when (op init-num com-num) ; When the condition is true, print and recur
      (println init-num)
      (recur (+ init-num inc-num) com-str com-num inc-num))))
    ; Else, terminate (implicit) 

Groovy, 51 bytes

{a,b,c,d->while(Eval.me("$a$b$c")){println a;a+=d}}

Este é um fechamento sem nome. Experimente Online!

Cuidado - Se você quiser testar isso groovy console, mate todo o processo quando a entrada causar um loop infinito. Percebi isso depois que consumiu ~ 5 GB de RAM.

QBIC , 51 40 bytes

:;::{?a┘a=a+c~A=@<`|~a>=b|_X]\~a<=b|_X

E três minutos após a postagem, percebi que poderia simplificar a lógica do terminador ...

:;::      Consecutively read a, A$, b and c from the command line
{?a┘      Start an infinite loop; print a, add a newline to the source
a=a+c     increment a
~A=@<`|   If we are in LESS THAN mode
  ~a>=b   and IF we are no longer LESS
    |_X]  THEN QUIT, end if.
  \       ELSE (we're in GREATER THAN mode)
    ~a<=b IF we are no longer GREATER
    |_X   THEN QUIT
          The last IF and the loop are auto-closed

Lote, 94 bytes

@set i=%1
@set o=gtr
@if "%~2"=="<" set o=lss
:g
@if %i% %o% %3 echo %i%&set/ai+=%4&goto g

Se não fosse o comportamento do segundo parâmetro, poderia ser feito em 53 bytes:

@for /l %%i in (%1,%4,%n%)do @if not %%i==%3 echo %%i

Isso simplesmente não faz nada se a etapa tiver o sinal errado. O teste extra é porque o forloop do lote permite que a variável do loop seja igual ao valor final.

Clojure, 66 bytes

#(loop[i %](if(({">">"<"<}%2)i %3)(do(println i)(recur(+ i %4)))))

Poderia ter 55 bytes <e >são funções no Clojure:

(def f #(loop[i %](if(%2 i %3)(do(println i)(recur(+ i %4))))))
(f 1 < 10 1)

TI-Basic, 41 34 bytes

Prompt A,Str2,Str3,D
While expr("A"+Str2+Str3
Disp A
A+D->A
End