イントロ

毎年、Dyalog Ltd.は学生コンテストを開催しています。そこでの課題は、優れた APLコードを書くことです。これは、今年の8番目の問題の言語に依存しないコードゴルフ版です。

コンテストの元の著者から、このチャレンジをここに投稿する明示的な許可があります。提供されたリンクに従って作成者に連絡することにより、気軽に確認してください。

問題

ブール*リストを指定すると、最初のTruthyの後のすべてのTruthiesを「オフ」にします。

真実はない？問題ない！変更せずにリストを返すだけです。

例

[falsy,truthy,falsy,truthy,falsy,falsy,truthy] → [falsy,truthy,falsy,falsy,falsy,falsy,falsy]

[] → []

[falsy,falsy,falsy,falsy] → [falsy,falsy,falsy,falsy]

*あなたのすべての真実は同一でなければならず、あなたのすべての偽りは同一でなければなりません。これには出力が含まれます。

Python 2、35バイト

while 1:b=input();print b;True&=b<1

オンラインでお試しください！入力と出力はTrue / Falseの行です。

デニスのソリューションに基づいています。入力が検出TrueさFalseれた後になるように変数を再定義しますTrue。これにより、の入力Trueは評価されFalse、そのように出力されます。

再定義はTrue&=b<1、つまりTrue = True & (b<1)です。入力bがのTrue場合、(b<1)はFalse（以降True==1）なので、にTrueなりFalseます。

APL、2バイト

<\

関数「より小さいを使用してスキャン」を評価します。 オンラインでお試しください！

説明

APLでは、演算子\（スキャン）は、提供された関数を使用して、配列の空でない接頭辞を右から減らします。たとえば、配列を指定すると、（長さ1のプレフィックス）、（長さ2のプレフィックス）、（長さ2のプレフィックス）を0 1 0計算し、結果を新しい配列に入れます。括弧は右側に関連付けられています。右側からby を減らすと、配列の最後の要素がであり、残りが正確であるため、左端に対応するプレフィックスはに、その他はに縮小されます。00<10<(1<0)<110110

Aceto、19 17バイトの非競合

新しいバージョン（17バイト）：

この新しいバージョンでは、キャラクターを一度に1つずつ取得し、-Fオプションで実行するのが最適です。以前のソリューションと似ていますが、同一ではありません。

 >,
Op0
p|1u
,ip^

古い回答（19バイト）：

（インタープリターの2つのバグを修正しなければならなかったため、競合しません）

|p1u
iOp<
|!`X
rd!r

これは、Acetoが比較的うまくできることを強調した最初のAcetoの回答です。「リスト」は入力ストリームで、1行に1つの入力、trueの場合は「1」、falseの場合は「0」で、空の文字列はリストの終わりを示します。

Acetoプログラムは、左下から右下で終わるヒルベルト曲線上で実行されます。最初に、r文字列を作成し、d複製し、それを否定（!）し、空の文字列をTrueに、他のすべてをFalseに変換します。次に、条件付き水平ミラー（|）があります。スタックの一番上の要素が真実であれば、水平にミラーします。これは、文字列が空のときに発生します。ミラーリングを行うと、に到達し、Xインタープリターが殺されます。

そうでない場合は、スタック上の残りのコピーをinteger に変換し、別の条件付き水平ミラーを実行します。今回は、1が真で0が偽であるため、（最初の）真の値が見つかった場合にミラーします。ミラーリングしない場合（pつまり、0が表示されます）、スタックのO内容をリントし（スタックが空でゼロであるため）、曲線の開始点にジャンプします。ここから開始し、プロセス全体を再び開始します。

それ以外の場合、1を見たときにミラーリングし、に着陸しますu。これにより、ヒルベルト曲線上を移動する方向が反転します。1p1を出力しO、0が表示されていた場合と同じように進みますが、「反転モード」なので、原点は右下にあるため、そこにジャンプします。

次にr、別の文字列を作成し、それを無効にします。文字列が空であり、したがって最上位のスタック要素が真である`場合、次のコマンド（）をエスケープせずにX終了します。

そうでない場合（文字列が空でなかった場合）、我々はない脱出Xし、それを無視します。その場合、左（<）に進み、p0をOリントし（スタックが空なので）、リギンに戻ります。

Java8、24の 19バイト

Long::highestOneBit

これが合法であることを願っています。私は、入力/出力が言語で真/偽として評価される必要がないという印象を受けました。入力として長い時間がかかり、出力として1が与えられます。バイナリ表現では1がtrue、0がfalseです。たとえば、バイナリ00101は5であり、4であるバイナリ00100を返します。

@puhlenのおかげで5バイト

網膜、6バイト

1>`1
0

オンラインでお試しください！

入力は、0s（Falseの場合）および1s（Trueの場合）のリストです。

すべてに一致し1、最初の（1>）以外のそれぞれをaに置き換えます0。

V、7バイト

f1òf1r0

オンラインでお試しください！

私の最初のV提出！\ o /

使い方

f1òf1r0
f1       "go to the next occurence of 1
  ò      "repeat the following until end:
   f1    "    go to the next occurence of 1
     r0  "    replace with 0

Haskell、25バイト

Boolsのリストを取得して返す匿名関数。

として使用し(foldr(\x l->x:map(x<)l)[])[False,True,False,False]ます。

foldr(\x l->x:map(x<)l)[]

オンラインでお試しください！

使い方

• 右からリストを折り返し、新しい要素を追加し、場合によっては次の要素を変更します。
• xは、サブリストの先頭に追加する要素lです。
• 用途False未満比較はTrue、そのmap(x<)lいずれかの電源を入れますTruesでlにFalseいる場合xですTrue。

ゼリー、4バイト

+\=a

オンラインでお試しください！

これは、他のほとんどのゴルフ言語ソリューションとはかなり異なるアルゴリズムです（投稿した後、Rソリューションもこのアルゴリズムを使用していることに気付きました）。そして、現在のJellyレコード所有者と結びついています。

説明

+\=a
+\    Cumulative sum of the input list
  =   Compare corresponding elements with the input
   a  Logical AND corresponding elements with the input

要素の左側のすべての要素が0である限り、要素までの累積合計は要素自体に等しくなります。最初の1の右側では、2つが異なります（現在、ゼロ以外の合計要素を左側に追加しているため）。したがって、+\=1（つまりtrue）から最初の真理値要素までを含むリストを提供します。最後に、元のリストとの論理ANDは、最初の真理値要素に対してのみ 1を与えます。

JavaScript（ES6）、33 26バイト

a=>a.map(e=>e&!(i-=e),i=1)

I / Oは0と1の配列です。

05AB1E、6バイト

コード：

ā<s1kQ

説明：

ā         # External enumeration, get a and push [1 .. len(a)]
 <        # Decrement each
  s       # Swap to get the input
   1k     # Get the first index of 1
     Q    # Check for equality with the enumeration array

05AB1Eエンコードを使用します。オンラインでお試しください！

チューリングマシンシミュレータ、39バイト

0 0 0 r 0
0 1 1 r 1
1 0 0 r 1
1 1 0 r 1

オンラインでお試しください！

brainfuck、55バイト

+>,[[->+>[->-<]>+[-<+>]<<<]>>[-<-<<[->>+<<]>>>]<.[-]<,]

オンラインでお試しください！

ゼリー、4バイト

05AB1E回答のポート。

i1=J

説明（引数α）：

i1        # Index of 1 (1-indexed) in α
  =       # Check for equality with the array:
   J      # [1 .. len(α)]

オンラインでお試しください！

R、24バイト

cumsum(T<-scan(,F))==T&T

オンラインでお試しください！

例：

入力をFALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==T返す場合TRUE TRUE FALSE FALSE。スキャンのFは、論理的な入力を保証します。
FALSE TRUE TRUE FALSEとTRUE TRUE FALSE FALSEですFALSE TRUE FALSE FALSE。シングル&は要素ごとの比較を行います。

オクターブ、23バイト

@(a)diff([0 cummax(a)])

オンラインでお試しください！

リストの累積最大値の最初の差。

J、3バイト

</\

モナド動詞を定義します。これは私のAPL答えのささいなポートです。 オンラインでお試しください！

Python、58バイト

lambda x:[x[i]and x.index(x[i])==i for i in range(len(x))]

場合はx[i]falseで、出力はfalseです。それ以外の場合は、要素がそれ自体の配列内で最初に出現するかどうかを示します。

PHP、37バイト

foreach($_GET as$v)echo$v*!$$v++,' ';

Perl 5、20バイト

sub{map$_&&!$x++,@_}

Truthy is 1およびfalsey is ''（空の文字列）。

説明：

mapリストitの要素をループし@_、引数をサブルーチンに渡し、各要素をローカルで$ _に設定し、各要素から計算した戻り値の配列を返します。if が偽であり、それが真実である場合に$_&&!$x++出力します。（&&は短絡しているため、最初の真理値に達するまで実行されないことに注意してください）。リターン（falseyである）、それは、次に実行され、第1の時間が毎回をインクリメント（などtruthyままです）。・無効、そしてそれがfalseyその後に遭遇され、第1の時間をtruthy返すようにします。$_$_!$x++!$x++$x++0!$x++

Pyth-9バイト

.e&b!s<Qk

ここで試してみてください

.e&b!s<Qk
.e          # Python's 'enumerate' (i.e., for each index k and each element b at that index)
      <Qk   # The first k elements of the input
     s      # 'Sum' these first k elements (with booleans, this is a logical 'or')
  &b!       # The value of the output at index k is [value of input @ index k]&&[the negation of the 'sum']

パイソン2、45の 36バイト

r=0
while 1:n=input();print n>r;r+=n

入力と出力は、行ごとに1 つのブール値（TrueまたはFalse）です。

オンラインでお試しください！

C＃、77バイト

a=>{var b=1<0;for(int i=0;i<a.Length;){a[i]=b?1<0:a[i];b|=a[i++];}return a;};

にコンパイルしますFunc<bool[], bool[]>。巧妙なものは何もありません。単純な解決策です。

sed、16 19バイト

15 18バイトのソースコード+ -rフラグの場合は1バイト（またはBSD sedの場合は-Eフラグ）。

:
s/1(0*)1/1\10/
t

オンラインでお試しください！

編集：間違いを指摘してくれたライリーに感謝します。

ゼリー、4 バイト

TḊṬ^

オンラインでお試しください！

どうやって？

これはかなり文字通りの意味で尋ねられたことを行います：

TḊṬ^ - Main link: list a   e.g. [0,1,0,1,0,0,1]  or  [0,1,0,1,0,1,0]
T    - get the truthy indexes   [  2,  4,    7]      [  2,  4,  6  ]
 Ḋ   - dequeue                  [      4,    7]      [      4,  6  ]
  T  - make a boolean array     [0,0,0,1,0,0,1]      [0,0,0,1,0,1  ]
   ^ - XOR that with a          [0,1,0,0,0,0,0]      [0,1,0,0,0,0,0]

c（gccビルトインを使用）、40

少し異なるアプローチ：

f(n){return!n?0:1<<31-__builtin_clz(n);}

これは無効と判断される場合があります-この場合、私は喜んでこれを非競合としてマークします。

入力と出力の「配列」は32ビットの符号なし整数です-これにより、入力リストのサイズが正確に32に制限されます-これは不適格かもしれません。入力の長さが32ビット未満の場合、最後にゼロビットが埋め込まれる場合があります。

オンラインでお試しください。

バッチ、85 73バイト

:a
@(if %1.==. exit)&set/ar=(1-f)*%1
@echo %r%&set/af^|=%1&shift&goto a

入力をコマンドライン引数として受け取ります。サンプルの場合：1.bat 0 1 0 1 0 0 1

前のバージョン

@set f=1
:a
@(if %1.==. exit)&set/ar=f*%1
@echo %r%&(if %1==1 set f=)&shift&goto a

Brain-Flak、230バイト

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<>({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{}(([])<{{}(({})())({<{}>{}((<()>))}<{}{}>)({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<>([]){{}({}<>)<>([])}{}<>{}{}([]){{}({}<>)<>([])}{}<>

私はすぐに説明しますが、私の母は私にいくつかのフライドポテトを調理しました

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<> Subtracts one from every item

({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{} Loops down stack until current item is zero and adds one

(([])<{{} (({})())({<{}>{}((<()>))}<{}{}>) ({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<> On every item of stack if it is 0 do nothing and if it is -1 add one

([]){{}({}<>)<>([])}{}<> Flip stack

{}{} Remove the two zeros at top of stack

([]){{}({}<>)<>([])}{}<> Flip stack back

オンラインでお試しください！

特別な感謝

コードで私を助けてくれたWheat WizardとRileyに特に感謝します！

Python 3、69 66 64 60 54 53バイト

lambda i:[k==i.index(j)and j for k,j in enumerate(i)]

falsesとtruesの配列を取ります。これはfalse、現在の反復の値がでtrueありtrue、入力の最初の値である場合を除き、sのリスト内包表記です。

これは少し長いようです（そして、私の最初のラムダです）。ゴルフの方法を見つけることができれば、それは大歓迎です！

Brain-Flak、146 144バイト

([]){{}({}<>)(())<>([])}{}<>((())){{}({}<>)<>}{}<>(()){{}((){[()](<{}>)}{})(<>)<>}<>(())<>([]){{}(<{}<>>)<>([])}{}<>{}{}([]){{}({}<>)<>([])}<>{}

オンラインでお試しください！

# Reverse the stack and add a 1 between each to help with reversing later
([]){{}({}<>)(())<>([])}{}<>

# Add a 1 in case there aren't any truthy values (and another 1 like before)
((()))

# Reverse the stack back to it's original order using the 1s from earlier to know when to stop
{{}({}<>)<>}{}<>

# Push 1 to start the loop
(())

# Until we find the first 1
{

 # Pop the last value
 {}

 # Logical not
 ((){[()](<{}>)}{})

  # Put a 0 on the other stack
  (<>)<>

# end loop
}

# Put a 1 on the other stack
<>(())<>

# Push the stack height
([])

# While there are values on this stack
{

 # Move them to the other stack as a 0
 {}(<{}<>>)<>([])

# End while
}{}

# Pop an extra 0
{}

# Switch stacks
<>

# Copy everything back (to reverse it back to it's original)
([])
{
 {}({}<>)<>([])
}<>{}

Perl 5、12バイト

10バイトのコード+の2 -pl。

$_&&=!$-++

オンラインでお試しください！