Harigami
ログイン
Harigamiは、ログイン不要のコード共有サービスです。コードの投稿後に発行されるURLでコードを共有できます。
PythonやRubyなど一部の言語は、投稿後にオンラインで実行することもできます。
誰でも無料で使えて、広告もありません。コードレビューやスニペットの代わりに使ってみてください。


詳細設定
+
anonymous タイトルなし
Python
//@version=3

study(title = "BBRSI", shorttitle = "BSI")

source = hlc3
length = input(20, minval=1), multi = input(2.0, minval=0.001,title="シグマ", maxval=50)
len = input(20, minval=1, title="移動平均線")

//RSI
rsi1 = rsi(source, length)

// BB of RSI
basis = sma(rsi1, length)
dev = multi * stdev(rsi1, length)
upper = basis + dev
lower = basis - dev
br = (rsi1 - lower)/(upper - lower)

//MA OF RSI
er = sma(br,len)
//アラート条件
LONG = crossover(br,er)
SHORT = crossunder(br,er)

switch = 0
setA = 0
setB = 0

if (LONG and (switch[1] == 0))
    switch := 1
    setA := 1
    setB := 0
else    
    if (SHORT and (switch[1] == 0))
        switch := 0
        setA := 0
        setB := 1
    else
        switch := nz(switch[0],0)
        setA := 0
        setB := 0
        
//コメント
alertcondition(setA, title = "LONG", message = "LLL!")
alertcondition(setB, title = "SHORT", message = "SSS!")

//COLOR
plot(br, color=aqua)
band1 = hline(1, color=silver, linestyle=dashed)
band0 = hline(0, color=silver, linestyle=dashed)
fill(band1, band0, color=green,transp=95)
plot(er, title="MA", style=circles, linewidth=1, color=orange)
  • 0
  • 2
anonymous タイトルなし
Python
//
// @author LazyBear 
//
// List of my public indicators: http://bit.ly/1LQaPK8 
// List of my app-store indicators: http://blog.tradingview.com/?p=970 
//
strategy(title="DecisionPoint Price Momentum Oscillator [LazyBear]", shorttitle="DPMO_LB")
src=input(close, title="Source")
length1=input(35, title="First Smoothing")
length2=input(20, title="Second Smoothing")
siglength=input(10, title="Signal Smoothing")
fr=input(true, title="Fill Region")
ehc=input(false, title="Enable Histo Color")
ebc=input(false, title="Enable Bar Colors")
soh=input(false, title="Show Only Histo")
slvl=input(false, title="Show OB/OS Levels")
oblvl=input(2.5, title="OB Level"), oslvl=input(-2.5, title="OS Level")
calc_csf(src, length) => 
	sm = 2.0/length
	csf=(src - nz(csf[1])) * sm + nz(csf[1])
	csf
i=(src/nz(src[1], src))*100
pmol2=calc_csf(i-100, length1)
pmol=calc_csf( 10 * pmol2, length2)
pmols=ema(pmol, siglength)
d=pmol-pmols

buy=crossover(pmol,pmols)
sel=crossunder(pmol,pmols)
strategy.entry("buy",true,when=buy)
strategy.entry("sel",false,when=sel)


duml=plot(not soh and fr?(d>0?pmol:pmols):na, style=circles, color=gray, linewidth=0, title="DummyL")
plot(0, title="MidLine")
hc=d>0?d>d[1]?lime:green:d<d[1]?red:orange
plot(d, style=columns, color=ehc?hc:gray, transp=80, title="Histo")
sigl=plot(soh?na:pmols, title="PMO Signal", color=gray, linewidth=2, title="Signal")
mdl=plot(soh?na:pmol, title="PMO", color=black, linewidth=2, title="PMO")
fill(duml, sigl, green, transp=70, title="PosFill")
fill(duml, mdl, red, transp=70, title="NegFill")
barcolor(ebc?hc:na)
plot(not soh and slvl?oblvl:na, title="OB Level", color=gray, linewidth=2)
plot(not soh and slvl?oslvl:na, title="OS Level", color=gray, linewidth=2)
  • 0
  • 1
anonymous タイトルなし
Python
//@version=3
study("CB+遅行線", overlay=true)
len=37
//DCC
i2 = input(len, "DCC", type=integer, minval=3)
eh = highest(high,i2)
el = lowest(low,i2)
r = eh - el
k = (close - el) / r
displacement = input(26, minval=1,title="遅行線")
//COLOR
P1 = plot(eh,color=aqua)
P2 = plot(el,color=aqua)
fill(P1 , P2 ,color=aqua)
plot(close,offset=-displacement+1, color=green, title="遅行スパン")
  • 0
  • 1
anonymous タイトルなし
Python
print('Hello, world!')
  • 0
  • 1
anonymous タイトルなし
C++

template< typename T >
struct edge {
	int from, to;
	T cost;

	edge(int to, T cost) : from(-1), to(to), cost(cost) {}

	edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}

	edge &operator=(const int &x) {
		to = x;
		return *this;
	}

	operator int() const { return to; }
};

template< typename T >
using Edges = vector< edge< T > >;

template< typename T >
vector< T > bellman_ford(Edges< T > &edges, int V, int s) {
	const auto INF = numeric_limits< T >::max();
	vector< T > dist(V, INF);
	dist[s] = 0;
	for (int i = 0; i < V - 1; i++) {
		for (auto &e : edges) {
			if (dist[e.from] == INF) continue;
			dist[e.to] = min(dist[e.to], dist[e.from] + e.cost);
		}
	}

	return dist;
}

//到達できるできない関係なしに、負の閉路があればtrueを返す
template< typename T >
bool find_negative_loopA(Edges< T > &edges, vector<T> &d, int V) {

	//距離の重みを0にしておくことで、始点から順番にたどるという行動をスキップして
	//単に構造として負の閉路をもっているかを調べられる
	vector< T > dist(V, 0);

	for (int i = 0; i < V; i++) {
		for (auto &e : edges) {
			if (d[e.to] > d[e.from] + e.cost) {
				d[e.to] = d[e.from] + e.cost;
				//負の閉路がなければV-1で終わる
				//負の閉路があるとV回目でも更新が起こる
				if (i == V - 1)return true;
			}
		}
	}

	return false;
}

//到達できる閉路があるかどうか
//稼いだあとにゴールできるかは問わない

//始点→終点→負の閉路→×終点のパターンはこの関数では検出できない
template< typename T >
bool find_negative_loopB(Edges< T > &edges, vector<T> &d, int V, int s) {

	for (int i = 0; i < V; i++) {
		for (auto &e : edges) {
			if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
				d[e.to] = d[e.from] + e.cost;
				//負の閉路がなければV-1で終わる
				//負の閉路があるとV回目でも更新が起こる
				if (i == V - 1)return true;
			}
		}
	}

	return false;
}


//始点から負の閉路に到達できて、かつ
//終点が負の閉路に含まれているパターン
//稼いだあとにゴールできる
template< typename T >
bool find_negative_loopC(Edges< T > &edges, vector<T> &d, int V, int s, int t) {


	//まず、V-1回の更新のあとに更新が起きてると負の閉路がある。
	//この閉路に終点が含まれていると無限に稼げてしまう
	//一つの大きな輪になってるとさらにV回かかる(これが最悪パターン)
	
	//V-1以降に更新が起こった時に、辺の行き先toが終点だったら
	//負の閉路に終点が含まれることになる。
	for (int i = 0; i < 2 * V; i++) {
		for (auto &e : edges) {
			if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
				d[e.to] = d[e.from] + e.cost;
				//負の閉路がなければV-1で終わる
				//負の閉路があるとV回目でも更新が起こる
				if (i >= V - 1 && e.to == t)return true;
			}
		}
	}

	return false;
}

//if (find_negative_loopB(es, dist, V, R)) {
//	cout << "NEGATIVE CYCLE" << endl;
//}
//else {
//	for (int i = 0; i < V; i++) {
//
//		if (dist[i] != INF) {
//			cout << dist[i] << endl;
//		}
//		else {
//			cout << "INF" << endl;
//		}
//
//	}
//}


//負の閉路がないとわかっているパターン
//vector< T > bellman_ford(Edges< T > &edges, int V, int s) 

//A 到達できるできない関係なしに、負の閉路があればtrueを返す
//負の閉路のチェックのみ(距離は無効)
//bool find_negative_loopA(Edges< T > &edges, vector<T> &dist, int V)

//B
//到達できる閉路があるかどうか
//稼いだあとにゴールできるかは問わない
//始点→終点→負の閉路→×終点のパターンはこの関数では検出できない
//template< typename T >
//bool find_negative_loopB(Edges< T > &edges, vector<T> &dist, int V, int s)

//C
//始点から負の閉路に到達できて、かつ
//終点が負の閉路に含まれているパターン
//稼いだあとにゴールできる

//bool find_negative_loopC(Edges< T > &edges, vector<T> &dist, int V, int s, int t)


int main() {

	int V, E, R;
	cin >> V >> E >> R;
	Edges<int> es;

	vector<int> x(E);
	vector<int> y(E);
	vector<int> z(E);

	for (int i = 0; i < E; i++) {
		cin >> x[i] >> y[i] >> z[i];
		x[i]--; y[i]--;
		es.emplace_back(x[i], y[i], z[i]);
		es.emplace_back(y[i], x[i], z[i]);
	}

	vector<int> dist;

	//たどり着けない最大値を指定する(10^9で間に合わなかったら書き換える)
	dist.resize(V, INF);

	dist[R] = 0;

	//上のコメントに関数があるので適宜選んで使う
	if (find_negative_loopC(es, dist, V, s, t)) {
		cout << "NEGATIVE CYCLE" << endl;
	}
	else {
		for (int i = 0; i < V; i++) {

		if (dist[i] != INF) {
			cout << dist[i] << endl;
		}
		else {
			cout << "INF" << endl;
		}

	}
	}



	return 0;

}
  • 0
  • 2
anonymous タイトルなし
JavaScript
console.log("Hello World");
  • 0
  • 1
anonymous ベルマンフォード2
Python
def BellmanFord(num_vertex, edges, source):
    inf = float('inf')

    # ある頂点までの距離(コスト)を記録するリスト
    costs = [inf for i in range(num_vertex)]
    costs[source-1] = 0

    for i in range(num_vertex):
        for edge in edges:

            # その辺の始点の頂点
            start = costs[edge[0]-1]
            # その辺の終点の頂点
            goal = costs[edge[1]-1]
            # コスト、距離、重み
            cost = edge[2]

            # 辺の緩和(よりコストの小さい経路を見つけたらリストを更新する)
            if edge[0] != inf and start + cost < goal:
                costs[edge[1]-1] = start + cost

                # 負閉路の検出
                if i == num_vertex-1:
                    return -1

    return costs
  • 0
  • 2
anonymous ベルマンフォード
Python
INF = float('inf')


def Bellmanford(node, edges, source):
    d = [INF] * node  # ある頂点までのコストを保存するリスト
    d[source] = 0

    for i in range(node):
        for start, goal, cost in edges:
            # 辺の始まりの頂点までのコストが INF でなく
            # 辺の向かう先の頂点のコストが、より軽くなる場合に、
            # リストを更新する
            if d[start] != INF and d[start] + cost < d[goal]:
                d[goal] = d[start] + cost
                if i == node-1 and goal == node-1:
                    return 'inf'
    return -d[node-1]


N, M = map(int, input().split())
abc = [map(int, input().split()) for _ in range(M)]
Edges = [None] * M

for i in range(M):
    ai, bi, ci = abc[i]
    Edges[i] = (ai-1, bi-1, -ci)


ans = Bellmanford(N, Edges, 0)
print(ans)

  • 0
  • 2
anonymous タイトルなし
HTML
<div><a href="https://line.me/ti/p/uVKk2Tsspk" target="_blank" title=""><img alt="ジャパカジLINEはじめました!詳細ページへ" class="full hidden-xs" src="/images/home/images/line/japacasi-line-ad-header-pc_751x96.jpg" style="" /><img alt="ジャパカジLINEはじめました!詳細ページへ" class="full visible-xs" src="/images/home/images/line/japacasi-line-ad-header-mobile_351x89.jpg" style="" /></a></div>
  • 0
  • 1
anonymous タイトルなし
PHP
<?php echo 'sss'?>
  • 0
  • 1